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);