[NTFS] - Add some fixes and improvements to attribute.c from CR-123:
[reactos.git] / 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");
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 CORE-1713) */
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 = STATUS_UNSUCCESSFUL;
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 /* HACK: the mouse has already been reset in i8042DetectMouse. This second
483 reset prevents some touchpads/mice from working (Dell D531, D600).
484 See CORE-6901 */
485 if (!(i8042HwFlags & FL_INITHACK))
486 {
487 i8042IsrWritePort(DeviceExtension, MOU_CMD_RESET, CTRL_WRITE_MOUSE);
488 }
489 KeReleaseInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt, Irql);
490 }
491
492 return Status;
493 }
494
495 static NTSTATUS
496 i8042PnpStartDevice(
497 IN PDEVICE_OBJECT DeviceObject,
498 IN PCM_RESOURCE_LIST AllocatedResources,
499 IN PCM_RESOURCE_LIST AllocatedResourcesTranslated)
500 {
501 PFDO_DEVICE_EXTENSION DeviceExtension;
502 PPORT_DEVICE_EXTENSION PortDeviceExtension;
503 PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor, ResourceDescriptorTranslated;
504 INTERRUPT_DATA InterruptData = { NULL };
505 BOOLEAN FoundDataPort = FALSE;
506 BOOLEAN FoundControlPort = FALSE;
507 BOOLEAN FoundIrq = FALSE;
508 ULONG i;
509 NTSTATUS Status;
510
511 TRACE_(I8042PRT, "i8042PnpStartDevice(%p)\n", DeviceObject);
512 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
513 PortDeviceExtension = DeviceExtension->PortDeviceExtension;
514
515 ASSERT(DeviceExtension->PnpState == dsStopped);
516
517 if (!AllocatedResources)
518 {
519 WARN_(I8042PRT, "No allocated resources sent to driver\n");
520 return STATUS_INSUFFICIENT_RESOURCES;
521 }
522 if (AllocatedResources->Count != 1)
523 {
524 WARN_(I8042PRT, "Wrong number of allocated resources sent to driver\n");
525 return STATUS_INSUFFICIENT_RESOURCES;
526 }
527 if (AllocatedResources->List[0].PartialResourceList.Version != 1
528 || AllocatedResources->List[0].PartialResourceList.Revision != 1
529 || AllocatedResourcesTranslated->List[0].PartialResourceList.Version != 1
530 || AllocatedResourcesTranslated->List[0].PartialResourceList.Revision != 1)
531 {
532 WARN_(I8042PRT, "Revision mismatch: %u.%u != 1.1 or %u.%u != 1.1\n",
533 AllocatedResources->List[0].PartialResourceList.Version,
534 AllocatedResources->List[0].PartialResourceList.Revision,
535 AllocatedResourcesTranslated->List[0].PartialResourceList.Version,
536 AllocatedResourcesTranslated->List[0].PartialResourceList.Revision);
537 return STATUS_REVISION_MISMATCH;
538 }
539
540 /* Get Irq and optionally control port and data port */
541 for (i = 0; i < AllocatedResources->List[0].PartialResourceList.Count; i++)
542 {
543 ResourceDescriptor = &AllocatedResources->List[0].PartialResourceList.PartialDescriptors[i];
544 ResourceDescriptorTranslated = &AllocatedResourcesTranslated->List[0].PartialResourceList.PartialDescriptors[i];
545 switch (ResourceDescriptor->Type)
546 {
547 case CmResourceTypePort:
548 {
549 if (ResourceDescriptor->u.Port.Length == 1)
550 {
551 /* We assume that the first resource will
552 * be the control port and the second one
553 * will be the data port...
554 */
555 if (!FoundDataPort)
556 {
557 PortDeviceExtension->DataPort = ULongToPtr(ResourceDescriptor->u.Port.Start.u.LowPart);
558 INFO_(I8042PRT, "Found data port: %p\n", PortDeviceExtension->DataPort);
559 FoundDataPort = TRUE;
560 }
561 else if (!FoundControlPort)
562 {
563 PortDeviceExtension->ControlPort = ULongToPtr(ResourceDescriptor->u.Port.Start.u.LowPart);
564 INFO_(I8042PRT, "Found control port: %p\n", PortDeviceExtension->ControlPort);
565 FoundControlPort = TRUE;
566 }
567 else
568 {
569 /* FIXME: implement PS/2 Active Multiplexing */
570 ERR_(I8042PRT, "Unhandled I/O ranges provided: 0x%lx\n", ResourceDescriptor->u.Port.Length);
571 }
572 }
573 else
574 WARN_(I8042PRT, "Invalid I/O range length: 0x%lx\n", ResourceDescriptor->u.Port.Length);
575 break;
576 }
577 case CmResourceTypeInterrupt:
578 {
579 if (FoundIrq)
580 return STATUS_INVALID_PARAMETER;
581 InterruptData.Dirql = (KIRQL)ResourceDescriptorTranslated->u.Interrupt.Level;
582 InterruptData.Vector = ResourceDescriptorTranslated->u.Interrupt.Vector;
583 InterruptData.Affinity = ResourceDescriptorTranslated->u.Interrupt.Affinity;
584 if (ResourceDescriptorTranslated->Flags & CM_RESOURCE_INTERRUPT_LATCHED)
585 InterruptData.InterruptMode = Latched;
586 else
587 InterruptData.InterruptMode = LevelSensitive;
588 InterruptData.ShareInterrupt = (ResourceDescriptorTranslated->ShareDisposition == CmResourceShareShared);
589 INFO_(I8042PRT, "Found irq resource: %lu\n", ResourceDescriptor->u.Interrupt.Level);
590 FoundIrq = TRUE;
591 break;
592 }
593 default:
594 WARN_(I8042PRT, "Unknown resource descriptor type 0x%x\n", ResourceDescriptor->Type);
595 }
596 }
597
598 if (!FoundIrq)
599 {
600 WARN_(I8042PRT, "Interrupt resource was not found in allocated resources list\n");
601 return STATUS_INSUFFICIENT_RESOURCES;
602 }
603 else if (DeviceExtension->Type == Keyboard && (!FoundDataPort || !FoundControlPort))
604 {
605 WARN_(I8042PRT, "Some required resources were not found in allocated resources list\n");
606 return STATUS_INSUFFICIENT_RESOURCES;
607 }
608 else if (DeviceExtension->Type == Mouse && (FoundDataPort || FoundControlPort))
609 {
610 WARN_(I8042PRT, "Too much resources were provided in allocated resources list\n");
611 return STATUS_INVALID_PARAMETER;
612 }
613
614 switch (DeviceExtension->Type)
615 {
616 case Keyboard:
617 {
618 RtlCopyMemory(
619 &PortDeviceExtension->KeyboardInterrupt,
620 &InterruptData,
621 sizeof(INTERRUPT_DATA));
622 PortDeviceExtension->Flags |= KEYBOARD_STARTED;
623 Status = StartProcedure(PortDeviceExtension);
624 break;
625 }
626 case Mouse:
627 {
628 RtlCopyMemory(
629 &PortDeviceExtension->MouseInterrupt,
630 &InterruptData,
631 sizeof(INTERRUPT_DATA));
632 PortDeviceExtension->Flags |= MOUSE_STARTED;
633 Status = StartProcedure(PortDeviceExtension);
634 break;
635 }
636 default:
637 {
638 WARN_(I8042PRT, "Unknown FDO type %u\n", DeviceExtension->Type);
639 ASSERT(!(PortDeviceExtension->Flags & KEYBOARD_CONNECTED) || !(PortDeviceExtension->Flags & MOUSE_CONNECTED));
640 Status = STATUS_INVALID_DEVICE_REQUEST;
641 }
642 }
643
644 if (NT_SUCCESS(Status))
645 DeviceExtension->PnpState = dsStarted;
646
647 return Status;
648 }
649
650 static VOID
651 i8042RemoveDevice(
652 IN PDEVICE_OBJECT DeviceObject)
653 {
654 PI8042_DRIVER_EXTENSION DriverExtension;
655 KIRQL OldIrql;
656 PFDO_DEVICE_EXTENSION DeviceExtension;
657
658 DriverExtension = (PI8042_DRIVER_EXTENSION)IoGetDriverObjectExtension(DeviceObject->DriverObject, DeviceObject->DriverObject);
659 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
660
661 KeAcquireSpinLock(&DriverExtension->DeviceListLock, &OldIrql);
662 RemoveEntryList(&DeviceExtension->ListEntry);
663 KeReleaseSpinLock(&DriverExtension->DeviceListLock, OldIrql);
664
665 IoDetachDevice(DeviceExtension->LowerDevice);
666
667 IoDeleteDevice(DeviceObject);
668 }
669
670 NTSTATUS NTAPI
671 i8042Pnp(
672 IN PDEVICE_OBJECT DeviceObject,
673 IN PIRP Irp)
674 {
675 PIO_STACK_LOCATION Stack;
676 ULONG MinorFunction;
677 I8042_DEVICE_TYPE DeviceType;
678 ULONG_PTR Information = 0;
679 NTSTATUS Status;
680
681 Stack = IoGetCurrentIrpStackLocation(Irp);
682 MinorFunction = Stack->MinorFunction;
683 DeviceType = ((PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Type;
684
685 switch (MinorFunction)
686 {
687 case IRP_MN_START_DEVICE: /* 0x00 */
688 {
689 TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
690
691 /* Call lower driver (if any) */
692 if (DeviceType != PhysicalDeviceObject)
693 {
694 Status = ForwardIrpAndWait(DeviceObject, Irp);
695 if (NT_SUCCESS(Status))
696 Status = i8042PnpStartDevice(
697 DeviceObject,
698 Stack->Parameters.StartDevice.AllocatedResources,
699 Stack->Parameters.StartDevice.AllocatedResourcesTranslated);
700 }
701 else
702 Status = STATUS_SUCCESS;
703 break;
704 }
705 case IRP_MN_QUERY_DEVICE_RELATIONS: /* (optional) 0x07 */
706 {
707 switch (Stack->Parameters.QueryDeviceRelations.Type)
708 {
709 case BusRelations:
710 {
711 TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
712 return ForwardIrpAndForget(DeviceObject, Irp);
713 }
714 case RemovalRelations:
715 {
716 TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations\n");
717 return ForwardIrpAndForget(DeviceObject, Irp);
718 }
719 default:
720 ERR_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
721 Stack->Parameters.QueryDeviceRelations.Type);
722 return ForwardIrpAndForget(DeviceObject, Irp);
723 }
724 break;
725 }
726 case IRP_MN_QUERY_CAPABILITIES: /* (optional) 0x09 */
727 {
728 TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_CAPABILITIES\n");
729 return ForwardIrpAndForget(DeviceObject, Irp);
730 }
731 case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: /* (optional) 0x0d */
732 {
733 TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
734 return ForwardIrpAndForget(DeviceObject, Irp);
735 }
736 case IRP_MN_QUERY_PNP_DEVICE_STATE: /* (optional) 0x14 */
737 {
738 TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_PNP_DEVICE_STATE\n");
739 return ForwardIrpAndForget(DeviceObject, Irp);
740 }
741 case IRP_MN_QUERY_REMOVE_DEVICE:
742 {
743 TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_REMOVE_DEVICE\n");
744 return ForwardIrpAndForget(DeviceObject, Irp);
745 }
746 case IRP_MN_CANCEL_REMOVE_DEVICE:
747 {
748 TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_CANCEL_REMOVE_DEVICE\n");
749 return ForwardIrpAndForget(DeviceObject, Irp);
750 }
751 case IRP_MN_REMOVE_DEVICE:
752 {
753 TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_REMOVE_DEVICE\n");
754 Status = ForwardIrpAndForget(DeviceObject, Irp);
755 i8042RemoveDevice(DeviceObject);
756 return Status;
757 }
758 default:
759 {
760 ERR_(I8042PRT, "IRP_MJ_PNP / unknown minor function 0x%x\n", MinorFunction);
761 return ForwardIrpAndForget(DeviceObject, Irp);
762 }
763 }
764
765 Irp->IoStatus.Information = Information;
766 Irp->IoStatus.Status = Status;
767 IoCompleteRequest(Irp, IO_NO_INCREMENT);
768 return Status;
769 }