reactos操作系统实现(95)

在PNP管理器里，最重要的处理，就是即插即用消息。下面来分析键盘的即插即用消息处理函数，实现的代码如下：

#001 NTSTATUS NTAPI
#002 i8042Pnp(
#003 IN PDEVICE_OBJECT DeviceObject,
#004 IN PIRP Irp)
#005 {
#006 PIO_STACK_LOCATION Stack;
#007 ULONG MinorFunction;
#008 I8042_DEVICE_TYPE DeviceType;
#009 ULONG_PTR Information = 0;
#010 NTSTATUS Status;
#011

获取IRP的栈。
#012 Stack = IoGetCurrentIrpStackLocation(Irp);

获取IRP次功能代码。
#013 MinorFunction = Stack->MinorFunction;

获取设备类型。
#014 DeviceType =
((PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Type;
#015

根据即插即用次功能代码处理。
#016 switch (MinorFunction)
#017 {

分配资源并启动一个设备。
#018 case IRP_MN_START_DEVICE: /* 0x00 */
#019 {
#020 TRACE_(I8042PRT, "IRP_MJ_PNP /
IRP_MN_START_DEVICE/n");
#021

如果设备类型不为物理设备类型，就处理。
#022 /* Call lower driver (if any) */
#023 if (DeviceType != PhysicalDeviceObject)
#024 {

向前传送IRP，并等待回应。
#025 Status = ForwardIrpAndWait(DeviceObject, Irp);

如果回应IRP成功，就调用i8042PnpStartDevice函数来分配资源。
#026 if (NT_SUCCESS(Status))
#027 Status = i8042PnpStartDevice(
#028 DeviceObject,
#029 Stack->Parameters.StartDevice.AllocatedResources,
#030 Stack->Parameters.StartDevice.AllocatedResourcesTranslated);
#031 }
#032 else
#033 Status = STATUS_SUCCESS;
#034 break;
#035 }

查询是否有子设备。
#036 case IRP_MN_QUERY_DEVICE_RELATIONS: /* (optional) 0x07 */
#037 {
#038 switch (Stack->Parameters.QueryDeviceRelations.Type)
#039 {

PNP 管理器向设备发送一个带有 BusRelations 码的
IRP_MN_QUERY_DEVICE_RELATIONS 的请求来获得设备的子设备列表，这里回应的子设备列表为0个。
#040 case BusRelations:
#041 {
#042 PDEVICE_RELATIONS DeviceRelations;
#043
#044 TRACE_(I8042PRT, "IRP_MJ_PNP /
IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations/n");
#045 DeviceRelations = ExAllocatePool(PagedPool,
sizeof(DEVICE_RELATIONS));
#046 if (DeviceRelations)
#047 {
#048 DeviceRelations->Count = 0;
#049 Information = (ULONG_PTR)DeviceRelations;
#050 Status = STATUS_SUCCESS;
#051 }
#052 else
#053 Status = STATUS_INSUFFICIENT_RESOURCES;
#054 break;
#055 }

这里处理即插即用的删除子设备的IRP。
#056 case RemovalRelations:
#057 {
#058 TRACE_(I8042PRT, "IRP_MJ_PNP /
IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations/n");
#059 return ForwardIrpAndForget(DeviceObject, Irp);
#060 }

缺省的IRP处理。
#061 default:
#062 ERR_(I8042PRT, "IRP_MJ_PNP /
IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx/n",
#063 Stack->Parameters.QueryDeviceRelations.Type);
#064 ASSERT(FALSE);
#065 return ForwardIrpAndForget(DeviceObject, Irp);
#066 }
#067 break;
#068 }

过滤系统请求的资源。
#069 case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: /* (optional) 0x0d
*/
#070 {
#071 TRACE_(I8042PRT, "IRP_MJ_PNP /
IRP_MN_FILTER_RESOURCE_REQUIREMENTS/n");
#072 /* Nothing to do */
#073 Status = Irp->IoStatus.Status;
#074 break;
#075 }
#076 default:
#077 {
#078 ERR_(I8042PRT, "IRP_MJ_PNP / unknown minor function
0x%x/n", MinorFunction);
#079 ASSERT(FALSE);
#080 return ForwardIrpAndForget(DeviceObject, Irp);
#081 }
#082 }
#083

IRP完成设置。
#084 Irp->IoStatus.Information = Information;
#085 Irp->IoStatus.Status = Status;
#086 IoCompleteRequest(Irp, IO_NO_INCREMENT);
#087 return Status;
#088 }
#089

接着来分析启动设备的消息，函数i8042PnpStartDevice的实现代码如下：
#001 static NTSTATUS
#002 i8042PnpStartDevice(
#003 IN PDEVICE_OBJECT DeviceObject,
#004 IN PCM_RESOURCE_LIST AllocatedResources,
#005 IN PCM_RESOURCE_LIST AllocatedResourcesTranslated)
#006 {
#007 PFDO_DEVICE_EXTENSION DeviceExtension;
#008 PPORT_DEVICE_EXTENSION PortDeviceExtension;
#009 PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor,
ResourceDescriptorTranslated;
#010 INTERRUPT_DATA InterruptData;
#011 BOOLEAN FoundDataPort = FALSE;
#012 BOOLEAN FoundControlPort = FALSE;
#013 BOOLEAN FoundIrq = FALSE;
#014 ULONG i;
#015 NTSTATUS Status;
#016
#017 TRACE_(I8042PRT, "i8042PnpStartDevice(%p)/n",
DeviceObject);

获取设备扩展对象。
#018 DeviceExtension =
(PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;

获取当前端口对象。
#019 PortDeviceExtension = DeviceExtension->PortDeviceExtension;
#020
#021 ASSERT(DeviceExtension->PnpState == dsStopped);
#022

即插即用管理器分配资源失败，因此直接返回。
#023 if (!AllocatedResources)
#024 {
#025 WARN_(I8042PRT, "No allocated resources sent to driver/n");
#026 return STATUS_INSUFFICIENT_RESOURCES;
#027 }

如果分配资源数量不对，就返回出错。
#028 if (AllocatedResources->Count != 1)
#029 {
#030 WARN_(I8042PRT, "Wrong number of allocated resources sent
to driver/n");
#031 return STATUS_INSUFFICIENT_RESOURCES;
#032 }

判断分配资源的版本是否一样，如果不一样也需要返回出错。
#033 if (AllocatedResources->List[0].PartialResourceList.Version !=
1
#034 ||
AllocatedResources->List[0].PartialResourceList.Revision != 1
#035 ||
AllocatedResourcesTranslated->List[0].PartialResourceList.Version != 1
#036 ||
AllocatedResourcesTranslated->List[0].PartialResourceList.Revision != 1)
#037 {
#038 WARN_(I8042PRT, "Revision mismatch: %u.%u != 1.1 or %u.%u
!= 1.1/n",
#039 AllocatedResources->List[0].PartialResourceList.Version,
#040 AllocatedResources->List[0].PartialResourceList.Revision,
#041 AllocatedResourcesTranslated->List[0].PartialResourceList.Version,
#042 AllocatedResourcesTranslated->List[0].PartialResourceList.Revision);
#043 return STATUS_REVISION_MISMATCH;
#044 }
#045

获取操作系统分配资源，比如端口地址和使用内存，还有中断号等等。
#046 /* Get Irq and optionally control port and data port */
#047 for (i = 0; i <
AllocatedResources->List[0].PartialResourceList.Count; i++)
#048 {

资源描述结构。
#049 ResourceDescriptor = &AllocatedResources->List[0].PartialResourceList.PartialDescriptors[i];
#050 ResourceDescriptorTranslated =
&AllocatedResourcesTranslated->List[0].PartialResourceList.PartialDescriptors[i];

根据资源类型来处理。
#051 switch (ResourceDescriptor->Type)
#052 {

分配的端口资源。
#053 case CmResourceTypePort:
#054 {

找到端口资源。
#055 if (ResourceDescriptor->u.Port.Length == 1)
#056 {
#057 /* We assume that the first ressource will
#058 * be the
control port and the second one
#059 * will be
the data port...
#060 */

先判断是否数据端口。
#061 if (!FoundDataPort)
#062 {

保存系统分配的数据端口地址。
#063 PortDeviceExtension->DataPort =
ULongToPtr(ResourceDescriptor-
#064 >u.Port.Start.u.LowPart);
#065 INFO_(I8042PRT, "Found data port:
%p/n", PortDeviceExtension->DataPort);
#066 FoundDataPort = TRUE;
#067 }
#068 else if (!FoundControlPort)
#069 {

保存系统分配的控制命令端口地址。
#070 PortDeviceExtension->ControlPort =
ULongToPtr(ResourceDescriptor-
#071 >u.Port.Start.u.LowPart);
#072 INFO_(I8042PRT, "Found control port:
%p/n", PortDeviceExtension->ControlPort);
#073 FoundControlPort = TRUE;
#074 }
#075 else
#076 {

其它是分配错误的端口地址。
#077 WARN_(I8042PRT, "Too much I/O ranges
provided: 0x%lx/n", ResourceDescriptor-
#078 >u.Port.Length);
#079 return STATUS_INVALID_PARAMETER;
#080 }
#081 }
#082 else
#083 WARN_(I8042PRT, "Invalid I/O range length:
0x%lx/n", ResourceDescriptor->u.Port.Length);
#084 break;
#085 }

这里处理系统分配的中断资源。
#086 case CmResourceTypeInterrupt:
#087 {

如果已经分配了中断，就返回出错。
#088 if (FoundIrq)
#089 return STATUS_INVALID_PARAMETER;

保存中断资源。
#090 InterruptData.Dirql =
(KIRQL)ResourceDescriptorTranslated->u.Interrupt.Level;
#091 InterruptData.Vector =
ResourceDescriptorTranslated->u.Interrupt.Vector;
#092 InterruptData.Affinity =
ResourceDescriptorTranslated->u.Interrupt.Affinity;

中断模式。
#093 if (ResourceDescriptorTranslated->Flags &
CM_RESOURCE_INTERRUPT_LATCHED)
#094 InterruptData.InterruptMode = Latched;
#095 else
#096 InterruptData.InterruptMode = LevelSensitive;

中断源是否共享。
#097 InterruptData.ShareInterrupt =
(ResourceDescriptorTranslated->ShareDisposition == CmResourceShareShared);
#098 INFO_(I8042PRT, "Found irq resource: %lu/n",
ResourceDescriptor->u.Interrupt.Level);
#099 FoundIrq = TRUE;
#100 break;
#101 }
#102 default:
#103 WARN_(I8042PRT, "Unknown resource descriptor type
0x%x/n", ResourceDescriptor->Type);
#104 }
#105 }
#106

如果没有分配中断资源，就返回出错。
#107 if (!FoundIrq)
#108 {
#109 WARN_(I8042PRT, "Interrupt resource was not found in
allocated resources list/n");
#110 return STATUS_INSUFFICIENT_RESOURCES;
#111 }
#112 else if (DeviceExtension->Type == Keyboard &&
(!FoundDataPort || !FoundControlPort))
#113 {

如果是键盘类型，但又没有分配数据端口和命令控制端口资源，也返回出错。
#114 WARN_(I8042PRT, "Some required resources were not found
in allocated resources list/n");
#115 return STATUS_INSUFFICIENT_RESOURCES;
#116 }
#117 else if (DeviceExtension->Type == Mouse &&
(FoundDataPort || FoundControlPort))
#118 {

如果是鼠标类型，但又没有分配数据端口和命令控制端口资源，也返回出错。
#119 WARN_(I8042PRT, "Too much resources were provided in
allocated resources list/n");
#120 return STATUS_INVALID_PARAMETER;
#121 }
#122

根据不同类型来处理。
#123 switch (DeviceExtension->Type)
#124 {
#125 case Keyboard:
#126 {

键盘类型处理，调用函数StartProcedure来处理键盘中断设置，并启动键盘。
#127 RtlCopyMemory(
#128 &PortDeviceExtension->KeyboardInterrupt,
#129 &InterruptData,
#130 sizeof(INTERRUPT_DATA));
#131 PortDeviceExtension->Flags |= KEYBOARD_STARTED;
#132 Status = StartProcedure(PortDeviceExtension);
#133 break;
#134 }
#135 case Mouse:
#136 {

鼠标类型处理，调用函数StartProcedure来处理鼠标中断设置，并启动鼠标。
#137 RtlCopyMemory(
#138 &PortDeviceExtension->MouseInterrupt,
#139 &InterruptData,
#140 sizeof(INTERRUPT_DATA));
#141 PortDeviceExtension->Flags |= MOUSE_STARTED;
#142 Status = StartProcedure(PortDeviceExtension);
#143 break;
#144 }
#145 default:
#146 {
#147 WARN_(I8042PRT, "Unknown FDO type %u/n",
DeviceExtension->Type);
#148 ASSERT(!(PortDeviceExtension->Flags &
KEYBOARD_CONNECTED) || !(PortDeviceExtension->Flags & MOUSE_CONNECTED));
#149 Status = STATUS_INVALID_DEVICE_REQUEST;
#150 }
#151 }
#152

这里设置即插即用初始化状态成功完成。
#153 if (NT_SUCCESS(Status))
#154 DeviceExtension->PnpState = dsStarted;
#155
#156 return Status;
#157 }

下面来分析函数StartProcedure的实现，代码如下：
#001 static NTSTATUS
#002 StartProcedure(
#003 IN PPORT_DEVICE_EXTENSION DeviceExtension)
#004 {
#005 NTSTATUS Status;
#006 UCHAR FlagsToDisable = 0;
#007 UCHAR FlagsToEnable = 0;
#008

如果检查没有数据端口，就立即返回。
#009 if (DeviceExtension->DataPort == 0)
#010 {
#011 /* Unable to do something at the moment */
#012 return STATUS_SUCCESS;
#013 }
#014

如果没有发现键盘或鼠标设备存在，就尽量尝试加载键盘或鼠标。
#015 if (!(DeviceExtension->Flags & (KEYBOARD_PRESENT |
MOUSE_PRESENT)))
#016 {
#017 /* Try to detect them */
#018 TRACE_(I8042PRT, "Check if the controller is really a
i8042/n");

检查设备是否存在。
#019 Status = i8042BasicDetect(DeviceExtension);
#020 if (!NT_SUCCESS(Status))
#021 {
#022 WARN_(I8042PRT, "i8042BasicDetect() failed with
status 0x%08lx/n", Status);

找不到设备，就返回。
#023 return STATUS_UNSUCCESSFUL;
#024 }
#025
#026 /* First detect the mouse and then the keyboard!
#027 If we do it the other
way round, some systems throw away settings like the keyboard translation, when
detecting the mouse.
#028

如果不是首次安装模式，就检测鼠标是否存在。
#029 Don't detect the
mouse if we're in 1st stage setup! */
#030 if(!IsFirstStageSetup())
#031 {
#032 TRACE_(I8042PRT, "Detecting mouse/n");
#033 i8042DetectMouse(DeviceExtension);
#034 }
#035

检测键盘。
#036 TRACE_(I8042PRT, "Detecting keyboard/n");
#037 i8042DetectKeyboard(DeviceExtension);
#038
#039 INFO_(I8042PRT, "Keyboard present: %s/n",
DeviceExtension->Flags & KEYBOARD_PRESENT ? "YES" :
"NO");
#040 INFO_(I8042PRT, "Mouse present : %s/n", DeviceExtension->Flags
& MOUSE_PRESENT ? "YES" : "NO");
#041 }
#042

设置键盘的中断处理。
#043 /* Connect interrupts */
#044 if (DeviceExtension->Flags & KEYBOARD_PRESENT &&
#045 DeviceExtension->Flags &
KEYBOARD_CONNECTED &&
#046 DeviceExtension->Flags &
KEYBOARD_STARTED &&
#047 !(DeviceExtension->Flags &
KEYBOARD_INITIALIZED))
#048 {

调用函数i8042ConnectKeyboardInterrupt来设置键盘中断处理函数。
#049 /* Keyboard is ready to be initialized */
#050 Status =
i8042ConnectKeyboardInterrupt(DeviceExtension->KeyboardExtension);
#051 if (NT_SUCCESS(Status))
#052 {
#053 DeviceExtension->Flags |= KEYBOARD_INITIALIZED;
#054 FlagsToDisable |= CCB_KBD_DISAB;
#055 FlagsToEnable |= CCB_KBD_INT_ENAB;
#056 }
#057 }
#058

设置鼠标的中断处理。
#059 if (DeviceExtension->Flags & MOUSE_PRESENT &&
#060 DeviceExtension->Flags &
MOUSE_CONNECTED &&
#061 DeviceExtension->Flags &
MOUSE_STARTED &&
#062 !(DeviceExtension->Flags &
MOUSE_INITIALIZED))
#063 {

调用函数i8042ConnectKeyboardInterrupt来设置鼠标中断处理。
#064 /* Mouse is ready to be initialized */
#065 Status =
i8042ConnectMouseInterrupt(DeviceExtension->MouseExtension);
#066 if (NT_SUCCESS(Status))
#067 {
#068 DeviceExtension->Flags |= MOUSE_INITIALIZED;
#069 FlagsToDisable |= CCB_MOUSE_DISAB;
#070 FlagsToEnable |= CCB_MOUSE_INT_ENAB;
#071 }
#072 }
#073

如果设置中断处理成功，就打开中断标志。
#074 if (FlagsToEnable)
#075 Status = EnableInterrupts(DeviceExtension, FlagsToDisable,
FlagsToEnable);
#076 else
#077 Status = STATUS_SUCCESS;
#078
#079 return Status;
#080 }

下面来分析中断设置函数i8042ConnectKeyboardInterrupt，代码如下：
#001 static NTSTATUS
#002
i8042ConnectKeyboardInterrupt(
#003 IN PI8042_KEYBOARD_EXTENSION DeviceExtension)
#004 {
#005 PPORT_DEVICE_EXTENSION PortDeviceExtension;
#006 KIRQL DirqlMax;
#007 NTSTATUS Status;
#008
#009 TRACE_(I8042PRT, "i8042ConnectKeyboardInterrupt()/n");
#010

获取设备端口。
#011 PortDeviceExtension =
DeviceExtension->Common.PortDeviceExtension;

取得最大中断级别。
#012 DirqlMax = MAX(
#013 PortDeviceExtension->KeyboardInterrupt.Dirql,
#014 PortDeviceExtension->MouseInterrupt.Dirql);
#015
#016 INFO_(I8042PRT, "KeyboardInterrupt.Vector %lu/n",
#017 PortDeviceExtension->KeyboardInterrupt.Vector);
#018 INFO_(I8042PRT, "KeyboardInterrupt.Dirql %lu/n",
#019 PortDeviceExtension->KeyboardInterrupt.Dirql);
#020 INFO_(I8042PRT, "KeyboardInterrupt.DirqlMax %lu/n",
#021 DirqlMax);
#022 INFO_(I8042PRT, "KeyboardInterrupt.InterruptMode %s/n",
#023 PortDeviceExtension->KeyboardInterrupt.InterruptMode ==
LevelSensitive ? "LevelSensitive" : "Latched");
#024 INFO_(I8042PRT, "KeyboardInterrupt.ShareInterrupt %s/n",
#025 PortDeviceExtension->KeyboardInterrupt.ShareInterrupt ?
"yes" : "no");
#026 INFO_(I8042PRT, "KeyboardInterrupt.Affinity 0x%lx/n",
#027 PortDeviceExtension->KeyboardInterrupt.Affinity);