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             WARN_(I8042PRT, "EnableInterrupts failed: %lx\n", Status);
 441             DeviceExtension->Flags &= ~(KEYBOARD_PRESENT | MOUSE_PRESENT);
 442             return Status;
 443         }
 444     }
 445
 446     /* Connect interrupts */
 447     if (DeviceExtension->Flags & KEYBOARD_PRESENT &&
 448         DeviceExtension->Flags & KEYBOARD_CONNECTED &&
 449         DeviceExtension->Flags & KEYBOARD_STARTED &&
 450         !(DeviceExtension->Flags & KEYBOARD_INITIALIZED))
 451     {
 452         /* Keyboard is ready to be initialized */
 453         Status = i8042ConnectKeyboardInterrupt(DeviceExtension->KeyboardExtension);
 454         if (NT_SUCCESS(Status))
 455         {
 456             DeviceExtension->Flags |= KEYBOARD_INITIALIZED;
 457         }
 458         else
 459         {
 460             WARN_(I8042PRT, "i8042ConnectKeyboardInterrupt failed: %lx\n", Status);
 461         }
 462     }
 463
 464     if (DeviceExtension->Flags & MOUSE_PRESENT &&
 465         DeviceExtension->Flags & MOUSE_CONNECTED &&
 466         DeviceExtension->Flags & MOUSE_STARTED &&
 467         !(DeviceExtension->Flags & MOUSE_INITIALIZED))
 468     {
 469         /* Mouse is ready to be initialized */
 470         Status = i8042ConnectMouseInterrupt(DeviceExtension->MouseExtension);
 471         if (NT_SUCCESS(Status))
 472         {
 473             DeviceExtension->Flags |= MOUSE_INITIALIZED;
 474         }
 475         else
 476         {
 477             WARN_(I8042PRT, "i8042ConnectMouseInterrupt failed: %lx\n", Status);
 478         }
 479
 480         /* Start the mouse */
 481         Irql = KeAcquireInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt);
 482         i8042IsrWritePort(DeviceExtension, MOU_CMD_RESET, CTRL_WRITE_MOUSE);
 483         KeReleaseInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt, Irql);
 484     }
 485
 486     return Status;
 487 }
 488
 489 static NTSTATUS
 490 i8042PnpStartDevice(
 491     IN PDEVICE_OBJECT DeviceObject,
 492     IN PCM_RESOURCE_LIST AllocatedResources,
 493     IN PCM_RESOURCE_LIST AllocatedResourcesTranslated)
 494 {
 495     PFDO_DEVICE_EXTENSION DeviceExtension;
 496     PPORT_DEVICE_EXTENSION PortDeviceExtension;
 497     PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor, ResourceDescriptorTranslated;
 498     INTERRUPT_DATA InterruptData;
 499     BOOLEAN FoundDataPort = FALSE;
 500     BOOLEAN FoundControlPort = FALSE;
 501     BOOLEAN FoundIrq = FALSE;
 502     ULONG i;
 503     NTSTATUS Status;
 504
 505     TRACE_(I8042PRT, "i8042PnpStartDevice(%p)\n", DeviceObject);
 506     DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 507     PortDeviceExtension = DeviceExtension->PortDeviceExtension;
 508
 509     ASSERT(DeviceExtension->PnpState == dsStopped);
 510
 511     if (!AllocatedResources)
 512     {
 513         WARN_(I8042PRT, "No allocated resources sent to driver\n");
 514         return STATUS_INSUFFICIENT_RESOURCES;
 515     }
 516     if (AllocatedResources->Count != 1)
 517     {
 518         WARN_(I8042PRT, "Wrong number of allocated resources sent to driver\n");
 519         return STATUS_INSUFFICIENT_RESOURCES;
 520     }
 521     if (AllocatedResources->List[0].PartialResourceList.Version != 1
 522      || AllocatedResources->List[0].PartialResourceList.Revision != 1
 523      || AllocatedResourcesTranslated->List[0].PartialResourceList.Version != 1
 524      || AllocatedResourcesTranslated->List[0].PartialResourceList.Revision != 1)
 525     {
 526         WARN_(I8042PRT, "Revision mismatch: %u.%u != 1.1 or %u.%u != 1.1\n",
 527             AllocatedResources->List[0].PartialResourceList.Version,
 528             AllocatedResources->List[0].PartialResourceList.Revision,
 529             AllocatedResourcesTranslated->List[0].PartialResourceList.Version,
 530             AllocatedResourcesTranslated->List[0].PartialResourceList.Revision);
 531         return STATUS_REVISION_MISMATCH;
 532     }
 533
 534     /* Get Irq and optionally control port and data port */
 535     for (i = 0; i < AllocatedResources->List[0].PartialResourceList.Count; i++)
 536     {
 537         ResourceDescriptor = &AllocatedResources->List[0].PartialResourceList.PartialDescriptors[i];
 538         ResourceDescriptorTranslated = &AllocatedResourcesTranslated->List[0].PartialResourceList.PartialDescriptors[i];
 539         switch (ResourceDescriptor->Type)
 540         {
 541             case CmResourceTypePort:
 542             {
 543                 if (ResourceDescriptor->u.Port.Length == 1)
 544                 {
 545                     /* We assume that the first resource will
 546                      * be the control port and the second one
 547                      * will be the data port...
 548                      */
 549                     if (!FoundDataPort)
 550                     {
 551                         PortDeviceExtension->DataPort = ULongToPtr(ResourceDescriptor->u.Port.Start.u.LowPart);
 552                         INFO_(I8042PRT, "Found data port: %p\n", PortDeviceExtension->DataPort);
 553                         FoundDataPort = TRUE;
 554                     }
 555                     else if (!FoundControlPort)
 556                     {
 557                         PortDeviceExtension->ControlPort = ULongToPtr(ResourceDescriptor->u.Port.Start.u.LowPart);
 558                         INFO_(I8042PRT, "Found control port: %p\n", PortDeviceExtension->ControlPort);
 559                         FoundControlPort = TRUE;
 560                     }
 561                     else
 562                     {
 563                         /* FIXME: implement PS/2 Active Multiplexing */
 564                         ERR_(I8042PRT, "Unhandled I/O ranges provided: 0x%lx\n", ResourceDescriptor->u.Port.Length);
 565                     }
 566                 }
 567                 else
 568                     WARN_(I8042PRT, "Invalid I/O range length: 0x%lx\n", ResourceDescriptor->u.Port.Length);
 569                 break;
 570             }
 571             case CmResourceTypeInterrupt:
 572             {
 573                 if (FoundIrq)
 574                     return STATUS_INVALID_PARAMETER;
 575                 InterruptData.Dirql = (KIRQL)ResourceDescriptorTranslated->u.Interrupt.Level;
 576                 InterruptData.Vector = ResourceDescriptorTranslated->u.Interrupt.Vector;
 577                 InterruptData.Affinity = ResourceDescriptorTranslated->u.Interrupt.Affinity;
 578                 if (ResourceDescriptorTranslated->Flags & CM_RESOURCE_INTERRUPT_LATCHED)
 579                     InterruptData.InterruptMode = Latched;
 580                 else
 581                     InterruptData.InterruptMode = LevelSensitive;
 582                 InterruptData.ShareInterrupt = (ResourceDescriptorTranslated->ShareDisposition == CmResourceShareShared);
 583                 INFO_(I8042PRT, "Found irq resource: %lu\n", ResourceDescriptor->u.Interrupt.Level);
 584                 FoundIrq = TRUE;
 585                 break;
 586             }
 587             default:
 588                 WARN_(I8042PRT, "Unknown resource descriptor type 0x%x\n", ResourceDescriptor->Type);
 589         }
 590     }
 591
 592     if (!FoundIrq)
 593     {
 594         WARN_(I8042PRT, "Interrupt resource was not found in allocated resources list\n");
 595         return STATUS_INSUFFICIENT_RESOURCES;
 596     }
 597     else if (DeviceExtension->Type == Keyboard && (!FoundDataPort || !FoundControlPort))
 598     {
 599         WARN_(I8042PRT, "Some required resources were not found in allocated resources list\n");
 600         return STATUS_INSUFFICIENT_RESOURCES;
 601     }
 602     else if (DeviceExtension->Type == Mouse && (FoundDataPort || FoundControlPort))
 603     {
 604         WARN_(I8042PRT, "Too much resources were provided in allocated resources list\n");
 605         return STATUS_INVALID_PARAMETER;
 606     }
 607
 608     switch (DeviceExtension->Type)
 609     {
 610         case Keyboard:
 611         {
 612             RtlCopyMemory(
 613                 &PortDeviceExtension->KeyboardInterrupt,
 614                 &InterruptData,
 615                 sizeof(INTERRUPT_DATA));
 616             PortDeviceExtension->Flags |= KEYBOARD_STARTED;
 617             Status = StartProcedure(PortDeviceExtension);
 618             break;
 619         }
 620         case Mouse:
 621         {
 622             RtlCopyMemory(
 623                 &PortDeviceExtension->MouseInterrupt,
 624                 &InterruptData,
 625                 sizeof(INTERRUPT_DATA));
 626             PortDeviceExtension->Flags |= MOUSE_STARTED;
 627             Status = StartProcedure(PortDeviceExtension);
 628             break;
 629         }
 630         default:
 631         {
 632             WARN_(I8042PRT, "Unknown FDO type %u\n", DeviceExtension->Type);
 633             ASSERT(!(PortDeviceExtension->Flags & KEYBOARD_CONNECTED) || !(PortDeviceExtension->Flags & MOUSE_CONNECTED));
 634             Status = STATUS_INVALID_DEVICE_REQUEST;
 635         }
 636     }
 637
 638     if (NT_SUCCESS(Status))
 639         DeviceExtension->PnpState = dsStarted;
 640
 641     return Status;
 642 }
 643
 644 NTSTATUS NTAPI
 645 i8042Pnp(
 646     IN PDEVICE_OBJECT DeviceObject,
 647     IN PIRP Irp)
 648 {
 649     PIO_STACK_LOCATION Stack;
 650     ULONG MinorFunction;
 651     I8042_DEVICE_TYPE DeviceType;
 652     ULONG_PTR Information = 0;
 653     NTSTATUS Status;
 654
 655     Stack = IoGetCurrentIrpStackLocation(Irp);
 656     MinorFunction = Stack->MinorFunction;
 657     DeviceType = ((PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Type;
 658
 659     switch (MinorFunction)
 660     {
 661         case IRP_MN_START_DEVICE: /* 0x00 */
 662         {
 663             TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
 664
 665             /* Call lower driver (if any) */
 666             if (DeviceType != PhysicalDeviceObject)
 667             {
 668                 Status = ForwardIrpAndWait(DeviceObject, Irp);
 669                 if (NT_SUCCESS(Status))
 670                     Status = i8042PnpStartDevice(
 671                         DeviceObject,
 672                         Stack->Parameters.StartDevice.AllocatedResources,
 673                         Stack->Parameters.StartDevice.AllocatedResourcesTranslated);
 674             }
 675             else
 676                 Status = STATUS_SUCCESS;
 677             break;
 678         }
 679         case IRP_MN_QUERY_DEVICE_RELATIONS: /* (optional) 0x07 */
 680         {
 681             switch (Stack->Parameters.QueryDeviceRelations.Type)
 682             {
 683                 case BusRelations:
 684                 {
 685                     PDEVICE_RELATIONS DeviceRelations;
 686
 687                     TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
 688                     DeviceRelations = ExAllocatePool(PagedPool, sizeof(DEVICE_RELATIONS));
 689                     if (DeviceRelations)
 690                     {
 691                         DeviceRelations->Count = 0;
 692                         Information = (ULONG_PTR)DeviceRelations;
 693                         Status = STATUS_SUCCESS;
 694                     }
 695                     else
 696                         Status = STATUS_INSUFFICIENT_RESOURCES;
 697                     break;
 698                 }
 699                 case RemovalRelations:
 700                 {
 701                     TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations\n");
 702                     return ForwardIrpAndForget(DeviceObject, Irp);
 703                 }
 704                 default:
 705                     ERR_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
 706                         Stack->Parameters.QueryDeviceRelations.Type);
 707                     ASSERT(FALSE);
 708                     return ForwardIrpAndForget(DeviceObject, Irp);
 709             }
 710             break;
 711         }
 712         case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: /* (optional) 0x0d */
 713         {
 714             TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
 715             /* Nothing to do */
 716             Status = Irp->IoStatus.Status;
 717             break;
 718         }
 719         case IRP_MN_QUERY_PNP_DEVICE_STATE: /* 0x14 */
 720         {
 721             TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_PNP_DEVICE_STATE\n");
 722             /* Nothing much to tell */
 723             Information = 0;
 724             Status = STATUS_SUCCESS;
 725             break;
 726         }
 727         default:
 728         {
 729             ERR_(I8042PRT, "IRP_MJ_PNP / unknown minor function 0x%x\n", MinorFunction);
 730             return ForwardIrpAndForget(DeviceObject, Irp);
 731         }
 732     }
 733
 734     Irp->IoStatus.Information = Information;
 735     Irp->IoStatus.Status = Status;
 736     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 737     return Status;
 738 }