reactos操作系统实现(92)

在DirverEntry函数，可以看到下面这句：

#054 DriverObject->DriverExtension->AddDevice = i8042AddDevice;

这里是设置了驱动程序的AddDevice函数指针，它是指向函数i8042AddDevice。PnP管理器将为每个硬件调用一次AddDevice函数，如下：

下面开始调用即插即用的函数AddDevice来添加设备。

#023 DPRINT("Calling %wZ->AddDevice(%wZ)/n",

#024 &DriverObject->DriverName,

#025 &DeviceNode->InstancePath);

#026 Status = DriverObject->DriverExtension->AddDevice(

#027 DriverObject, DeviceNode->PhysicalDeviceObject);

#028 if (!NT_SUCCESS(Status))

#029 {

#030 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);

#031 return Status;

#032 }

#033

上面第26行，就是PnP管理器调用AddDevice函数，可见给这个函数传送了两个参数，一个是驱动程序对象，一个是物理设备对象。由于DirverEntry只能每次加载驱动程序时调用一次，但一个驱动程序可以创建多个设备，那么就需要一个函数来创建设备，这个函数就是AddDevice函数。现在来分析键盘添加设备的函数，如下：

#001 NTSTATUS NTAPI

#002 i8042AddDevice(

#003 IN PDRIVER_OBJECT DriverObject,

#004 IN PDEVICE_OBJECT Pdo)

#005 {

#006 PI8042_DRIVER_EXTENSION DriverExtension;

#007 PFDO_DEVICE_EXTENSION DeviceExtension = NULL;

#008 PDEVICE_OBJECT Fdo = NULL;

#009 ULONG DeviceExtensionSize;

#010 NTSTATUS Status;

#011

#012 TRACE_(I8042PRT, "i8042AddDevice(%p %p)/n", DriverObject, Pdo);

#013

获取前面分配的驱动程序扩展对象。

#014 DriverExtension = (PI8042_DRIVER_EXTENSION)IoGetDriverObjectExtension(DriverObject, DriverObject);

#015

判断输入的物理设备对象是否合法，如果不合法就返回。

#016 if (Pdo == NULL)

#017 {

#018 /* We're getting a NULL Pdo at the first call as

#019 * we are a legacy driver. Ignore it */

#020 return STATUS_SUCCESS;

#021 }

#022

#023 /* Create new device object. As we don't know if the device would be a keyboard

#024 * or a mouse, we have to allocate the biggest device extension. */

分配一个设备内存，由于这个驱动程序支持两种输入类型，一种是鼠标，一种是键盘，因此只能分配最大内存的设备对象。

#025 DeviceExtensionSize = MAX(sizeof(I8042_KEYBOARD_EXTENSION), sizeof(I8042_MOUSE_EXTENSION));

调用函数IoCreateDevice来创建物理设备对象。

#026 Status = IoCreateDevice(

#027 DriverObject,

#028 DeviceExtensionSize,

#029 NULL,

#030 Pdo->DeviceType,

#031 FILE_DEVICE_SECURE_OPEN,

#032 TRUE,

#033 &Fdo);

#034 if (!NT_SUCCESS(Status))

#035 {

#036 WARN_(I8042PRT, "IoCreateDevice() failed with status 0x%08lx/n", Status);

#037 goto cleanup;

#038 }

#039

设置物理设备对象的属性。

#040 DeviceExtension = (PFDO_DEVICE_EXTENSION)Fdo->DeviceExtension;

#041 RtlZeroMemory(DeviceExtension, DeviceExtensionSize);

#042 DeviceExtension->Type = Unknown;

#043 DeviceExtension->Fdo = Fdo;

#044 DeviceExtension->Pdo = Pdo;

#045 DeviceExtension->PortDeviceExtension = &DriverExtension->Port;

调用函数IoAttachDeviceToDeviceStackSafe把新设备放到设备栈上。

#046 Status = IoAttachDeviceToDeviceStackSafe(Fdo, Pdo, &DeviceExtension->LowerDevice);

#047 if (!NT_SUCCESS(Status))

#048 {

#049 WARN_(I8042PRT, "IoAttachDeviceToDeviceStackSafe() failed with status 0x%08lx/n", Status);

#050 goto cleanup;

#051 }

#052

把设备添加设备队列。

#053 ExInterlockedInsertTailList(

#054 &DriverExtension->DeviceListHead,

#055 &DeviceExtension->ListEntry,

#056 &DriverExtension->DeviceListLock);

#057

设置物理设备对象已经初始化。

#058 Fdo->Flags &= ~DO_DEVICE_INITIALIZING;

#059 return STATUS_SUCCESS;

#060

不成功时清除动作。

#061 cleanup:

#062 if (DeviceExtension && DeviceExtension->LowerDevice)

#063 IoDetachDevice(DeviceExtension->LowerDevice);

#064 if (Fdo)

#065 IoDeleteDevice(Fdo);

#066 return Status;

#067 }

#068

通过上面的函数分析，可以看到键盘驱动程序是怎么样实现AddDevice函数的，大体的步骤如下：

1） 调用函数IoCreateDevice创建设备对象，并建立一个私有的设备扩展对象。

2） 调用函数IoAttachDeviceToDeviceStackSafe，把新设备对象放到堆栈上。

3） 把新设备添加到设备队列。

4） 初始化设备对象的Flag成员。

下面来分析i8042StartIo函数的实现，它主要处理标准的IRP排队方式。

#001 static VOID NTAPI

#002 i8042StartIo(

#003 IN PDEVICE_OBJECT DeviceObject,

#004 IN PIRP Irp)

#005 {

#006 PFDO_DEVICE_EXTENSION DeviceExtension;

#007

获取驱动程序扩展。

#008 DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;

根据驱动程序创建的设备类型来处理。

#009 switch (DeviceExtension->Type)

#010 {

这里是处理键盘的IRP。

#011 case Keyboard:

#012 i8042KbdStartIo(DeviceObject, Irp);

#013 break;

#014 default:

#015 ERR_(I8042PRT, "Unknown FDO type %u/n", DeviceExtension->Type);

#016 ASSERT(FALSE);

#017 break;

#018 }

#019 }

这个函数调用是在内核的I/O管理器里调用，主要在这几个函数里调用：

IoStartPacket

IopStartNextPacket

IopStartNextPacketByKey

接着来分析函数i8042KbdStartIo的实现，如下：

#001 VOID NTAPI

#002 i8042KbdStartIo(

#003 IN PDEVICE_OBJECT DeviceObject,

#004 IN PIRP Irp)

#005 {

#006 PIO_STACK_LOCATION Stack;

#007 PI8042_KEYBOARD_EXTENSION DeviceExtension;

#008 PPORT_DEVICE_EXTENSION PortDeviceExtension;

#009

获取当前IRP栈。

#010 Stack = IoGetCurrentIrpStackLocation(Irp);

获取设备扩展结构。

#011 DeviceExtension = (PI8042_KEYBOARD_EXTENSION)DeviceObject->DeviceExtension;

获取端口描述结构。

#012 PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;

#013

根据IoControlCode来处理。

#014 switch (Stack->Parameters.DeviceIoControl.IoControlCode)

#015 {

设置键盘的指示灯。

#016 case IOCTL_KEYBOARD_SET_INDICATORS:

#017 {

#018 TRACE_(I8042PRT, "IOCTL_KEYBOARD_SET_INDICATORS/n");

#019 INFO_(I8042PRT, "Leds: {%s%s%s }/n",

#020 DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_CAPS_LOCK_ON ? " CAPSLOCK" : "",

#021 DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_NUM_LOCK_ON ? " NUMLOCK" : "",

#022 DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_SCROLL_LOCK_ON ? " SCROLLLOCK" : "");

#023

设置要写到键盘端口的指示灯数据。

#024 PortDeviceExtension->PacketBuffer[0] = KBD_CMD_SET_LEDS;

#025 PortDeviceExtension->PacketBuffer[1] = 0;

#026 if (DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_CAPS_LOCK_ON)

#027 PortDeviceExtension->PacketBuffer[1] |= KBD_LED_CAPS;

#028

#029 if (DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_NUM_LOCK_ON)

#030 PortDeviceExtension->PacketBuffer[1] |= KBD_LED_NUM;

#031

#032 if (DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_SCROLL_LOCK_ON)

#033 PortDeviceExtension->PacketBuffer[1] |= KBD_LED_SCROLL;

#034

调用函数i8042StartPacket来处理指示灯的IRP。

#035 i8042StartPacket(

#036 PortDeviceExtension,

#037 &DeviceExtension->Common,

#038 PortDeviceExtension->PacketBuffer,

#039 2,

#040 Irp);

#041 break;

#042 }

#043 default:

#044 {

#045 ERR_(I8042PRT, "Unknown ioctl code 0x%lx/n",

#046 Stack->Parameters.DeviceIoControl.IoControlCode);

#047 ASSERT(FALSE);

#048 }

#049 }

#050 }

接着来分析函数i8042StartPacket的实现，这个函数必须在DIRQL级别下调用，如下：

#001 NTSTATUS

#002 i8042StartPacket(

#003 IN PPORT_DEVICE_EXTENSION DeviceExtension,

#004 IN PFDO_DEVICE_EXTENSION FdoDeviceExtension,

#005 IN PUCHAR Bytes,

#006 IN ULONG ByteCount,

#007 IN PIRP Irp)

#008 {

#009 KIRQL Irql;

#010 NTSTATUS Status;

#011

获取设备请求级别。

#012 Irql = KeAcquireInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt);

#013

如果设备不空闲，就直接返回。

#014 if (DeviceExtension->Packet.State != Idle)

#015 {

#016 Status = STATUS_DEVICE_BUSY;

#017 goto done;

#018 }

#019

根据设备类型来决定分配访问端口。

#020 switch (FdoDeviceExtension->Type)

#021 {

键盘是从端口偏移0开始。

#022 case Keyboard: DeviceExtension->PacketPort = 0; break;

鼠标是从端口偏移CTRL_WRITE_MOUSE开始。

#023 case Mouse: DeviceExtension->PacketPort = CTRL_WRITE_MOUSE; break;

#024 default:

#025 ERR_(I8042PRT, "Unknown FDO type %u/n", FdoDeviceExtension->Type);

#026 ASSERT(FALSE);

#027 Status = STATUS_INTERNAL_ERROR;

#028 goto done;

#029 }

#030

设置将要写到端里的字节，以及相关的数据描述。

#031 DeviceExtension->Packet.Bytes = Bytes;

#032 DeviceExtension->Packet.CurrentByte = 0;

#033 DeviceExtension->Packet.ByteCount = ByteCount;

标记设备正在发送中。

#034 DeviceExtension->Packet.State = SendingBytes;

#035 DeviceExtension->PacketResult = Status = STATUS_PENDING;

#036 DeviceExtension->CurrentIrp = Irp;

#037 DeviceExtension->CurrentIrpDevice = FdoDeviceExtension->Fdo;

#038

调用函数i8042PacketWrite把IRP发送到设备。

#039 if (!i8042PacketWrite(DeviceExtension))

#040 {

#041 Status = STATUS_IO_TIMEOUT;

#042 DeviceExtension->Packet.State = Idle;

#043 DeviceExtension->PacketResult = STATUS_ABANDONED;

#044 goto done;

#045 }

#046

#047 DeviceExtension->Packet.CurrentByte++;

#048

#049 done:

#050 KeReleaseInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt, Irql);

#051

如果状态不是阻塞状态，就立即设置这个IRP已经完成。

#052 if (Status != STATUS_PENDING)

#053 {

#054 DeviceExtension->CurrentIrp = NULL;

#055 DeviceExtension->CurrentIrpDevice = NULL;

#056 Irp->IoStatus.Status = Status;

#057 IoCompleteRequest(Irp, IO_NO_INCREMENT);

#058 }

#059 return Status;

#060 }

接着来分析函数i8042PacketWrite，如下：

#001 static BOOLEAN

#002 i8042PacketWrite(

#003 IN PPORT_DEVICE_EXTENSION DeviceExtension)

#004 {

获取键盘或鼠标的输出数据的端口。

#005 UCHAR Port = DeviceExtension->PacketPort;

#006

如果端口存在是一个控制端口命令，否则就是数据端口命令。

#007 if (Port)

#008 {

#009 if (!i8042Write(DeviceExtension,

#010 DeviceExtension->ControlPort,

#011 Port))

#012 {

#013 /* something is really wrong! */

#014 WARN_(I8042PRT, "Failed to send packet byte!/n");

#015 return FALSE;

#016 }

#017 }

#018

这里把数据写到数据端口命令。

#019 return i8042Write(DeviceExtension,

#020 DeviceExtension->DataPort,

#021 DeviceExtension->Packet.Bytes[DeviceExtension->Packet.CurrentByte]);

#022 }

接着再来查看函数i8042Write的实现，如下：

#001 BOOLEAN

#002 i8042Write(

#003 IN PPORT_DEVICE_EXTENSION DeviceExtension,

#004 IN PUCHAR addr,

#005 IN UCHAR data)

#006 {

#007 ULONG Counter;

#008

#009 ASSERT(addr);

#010 ASSERT(DeviceExtension->ControlPort != NULL);

#011

Counter指定要放弃和超时操作之前轮询硬件 （以轮询模式） 的时间标准数。 请考虑增加此值，如果该驱动程序无法初始化或正常工作，并且事件查看器中的系统日志包含 i8042prt 源中的以下信息："操作正在超时 （出是通过注册表配置的时间）"

#012 Counter = DeviceExtension->Settings.PollingIterations;

#013

等待键盘设备空闲。

#014 while ((KBD_IBF & READ_PORT_UCHAR(DeviceExtension->ControlPort)) &&

#015 (Counter--))

#016 {

#017 KeStallExecutionProcessor(50);

#018 }

#019

如果没有超时，就可以把键盘操作数据发送给键盘设备。

#020 if (Counter)

#021 {

调用CPU操作IO的指令，第一个参数是端口地址，第二个端口的数据。

#022 WRITE_PORT_UCHAR(addr, data);

#023 INFO_(I8042PRT, "Sent 0x%x to port %p/n", data, addr);

#024 return TRUE;

#025 }

#026 return FALSE;

#027 }

到这里，就已经把i8042StartIo处理的IRP完全发送到键盘设备了，然后键盘设备就会响应这些指令。由整个过程可见，DriverStartIo函数其实就是立即处理IO管理器发送过来的端口操作命令。