windows 内核驱动通过哪些方式直接访问硬件

Windows 内核驱动可以通过以下几种主要方式直接访问硬件：

1. 内存映射 I/O (Memory-Mapped I/O, MMIO)

   - 使用 MmMapIoSpace 函数将物理地址映射到虚拟地址空间
   - 直接读写映射后的内存地址来访问硬件寄存器

   示例：
   ```c
   PHYSICAL_ADDRESS physicalAddress;
   PVOID virtualAddress;
   
   physicalAddress.QuadPart = 0x12345000;  // 硬件寄存器的物理地址
   virtualAddress = MmMapIoSpace(physicalAddress, 0x1000, MmNonCached);
   
   // 读取寄存器
   ULONG value = READ_REGISTER_ULONG((PULONG)virtualAddress);
   
   // 写入寄存器
   WRITE_REGISTER_ULONG((PULONG)virtualAddress, newValue);
   
   // 使用完毕后解除映射
   MmUnmapIoSpace(virtualAddress, 0x1000);
   ```

2. 端口 I/O (Port I/O)

   - 使用 READ_PORT_XXX 和 WRITE_PORT_XXX 宏直接访问 I/O 端口
   - 适用于较旧的硬件或特定的硬件接口

   示例：
   ```c
   // 读取端口
   UCHAR value = READ_PORT_UCHAR((PUCHAR)0x378);
   
   // 写入端口
   WRITE_PORT_UCHAR((PUCHAR)0x378, 0x55);
   ```

3. 直接内存访问 (Direct Memory Access, DMA)

   - 使用 HalAllocateCommonBuffer 或 WdfDmaEnablerCreate 等函数设置 DMA 传输
   - 允许硬件直接访问系统内存，减少 CPU 干预

   示例（使用 WDF）：
   ```c
   WDFDMAENABLER dmaEnabler;
   NTSTATUS status;
   
   status = WdfDmaEnablerCreate(device, 
                                &dmaEnablerConfig, 
                                WDF_NO_OBJECT_ATTRIBUTES,
                                &dmaEnabler);
   if (!NT_SUCCESS(status)) {
       // 处理错误
   }
   
   // 使用 dmaEnabler 进行后续 DMA 操作
   ```

4. 程序化 I/O (Programmed I/O, PIO)

   - 通过 CPU 指令直接读写硬件寄存器
   - 通常用于简单的数据传输或配置操作

5. 中断处理

   - 注册中断服务例程 (ISR) 来响应硬件中断
   - 使用 IoConnectInterrupt 或 WdfInterruptCreate 函数

   示例（使用 WDF）：
   ```c
   WDFINTERRUPT interrupt;
   NTSTATUS status;
   
   WDF_INTERRUPT_CONFIG interruptConfig;
   WDF_INTERRUPT_CONFIG_INIT(&interruptConfig, 
                             InterruptIsr, 
                             InterruptDpc);
   
   status = WdfInterruptCreate(device,
                               &interruptConfig,
                               WDF_NO_OBJECT_ATTRIBUTES,
                               &interrupt);
   if (!NT_SUCCESS(status)) {
       // 处理错误
   }
   ```

6. 内存栅栏 (Memory Barriers)

   - 使用 KeMemoryBarrier 确保内存操作的正确顺序
   - 在多核系统上特别重要

7. 硬件抽象层 (HAL) 函数

   - 使用 HAL 提供的函数进行某些硬件操作
   - 例如，HalGetInterruptVector 用于获取中断向量

8. 设备树和资源列表

   - 通过解析设备树和资源列表获取硬件信息
   - 使用 CM_Get_xxx 函数族或 WDF 对应的函数

注意事项：
- 直接访问硬件需要非常小心，错误的操作可能导致系统不稳定或崩溃
- 应遵循 Windows 驱动程序开发的最佳实践和指南
- 在可能的情况下，优先使用更高级的抽象（如 WDF）来简化开发并提高安全性
- 对于 PCI 设备，应使用 PCI 配置空间访问函数而不是直接访问
- 在访问硬件之前，确保已正确获取和映射资源

通过这些方法，Windows 内核驱动程序可以直接与硬件交互，实现底层的设备控制和数据传输。
 

9. PCI 配置空间访问

对于 PCI 设备，应使用专门的函数访问配置空间，而不是直接访问硬件：

```c
// 读取 PCI 配置空间
ULONG value;
status = HalGetBusDataByOffset(PCIConfiguration,
                               busNumber,
                               slotNumber,
                               &value,
                               offset,
                               sizeof(ULONG));

// 写入 PCI 配置空间
status = HalSetBusDataByOffset(PCIConfiguration,
                               busNumber,
                               slotNumber,
                               &newValue,
                               offset,
                               sizeof(ULONG));
```

10. 自旋锁（Spinlock）

在访问共享硬件资源时，使用自旋锁确保同步：

```c
KSPIN_LOCK spinLock;
KIRQL oldIrql;

KeInitializeSpinLock(&spinLock);

// 获取自旋锁
KeAcquireSpinLock(&spinLock, &oldIrql);

// 访问硬件...

// 释放自旋锁
KeReleaseSpinLock(&spinLock, oldIrql);
```

11. 电源管理

实现适当的电源管理回调，以处理设备的电源状态变化：

```c
NTSTATUS
PowerDeviceD0Entry(
    _In_ WDFDEVICE Device,
    _In_ WDF_POWER_DEVICE_STATE PreviousState
)
{
    // 初始化硬件，从低功耗状态恢复
    // ...
    return STATUS_SUCCESS;
}

NTSTATUS
PowerDeviceD0Exit(
    _In_ WDFDEVICE Device,
    _In_ WDF_POWER_DEVICE_STATE TargetState
)
{
    // 将硬件置于低功耗状态
    // ...
    return STATUS_SUCCESS;
}
```

12. 硬件定时器

使用硬件定时器来实现精确的时间控制：

```c
WDFTIMER timer;
WDF_TIMER_CONFIG timerConfig;

WDF_TIMER_CONFIG_INIT(&timerConfig, TimerEvtCallback);
timerConfig.Period = 100; // 100 毫秒

status = WdfTimerCreate(&timerConfig,
                        WDF_NO_OBJECT_ATTRIBUTES,
                        device,
                        &timer);
```

13. 内存描述符列表（MDL）

使用 MDL 进行大块数据传输，特别是在 DMA 操作中：

```c
PMDL mdl;
PVOID buffer;

mdl = IoAllocateMdl(buffer, bufferSize, FALSE, FALSE, NULL);
if (mdl == NULL) {
    // 处理错误
}

__try {
    MmProbeAndLockPages(mdl, KernelMode, IoReadAccess);
} __except(EXCEPTION_EXECUTE_HANDLER) {
    IoFreeMdl(mdl);
    // 处理异常
}

// 使用 mdl 进行 DMA 或其他操作

// 完成后解锁和释放
MmUnlockPages(mdl);
IoFreeMdl(mdl);
```

14. 硬件抽象层（HAL）扩展

某些特定硬件可能需要扩展 HAL：

```c
HalRegisterPlatformSecondLevelInterruptHandler(
    SecondLevelInterruptHandler,
    HardwareInterruptSource,
    &InterruptObject
);
```

15. 安全性考虑

- 验证所有来自用户模式的输入
- 使用安全的内存分配和访问方法
- 实现适当的访问控制

```c
// 验证用户模式缓冲区
ProbeForRead(UserBuffer, BufferSize, sizeof(UCHAR));

// 安全的内存复制
status = RtlCopyMemory_s(KernelBuffer, 
                         KernelBufferSize, 
                         UserBuffer, 
                         BufferSize);
```

16. 硬件模拟和虚拟化

在某些情况下，可能需要模拟或虚拟化硬件：

```c
// 创建虚拟设备接口
status = IoCreateDeviceInterface(
    DeviceObject,
    &GUID_DEVINTERFACE_VIRTUAL_DEVICE,
    NULL,
    &symbolicLinkName
);
```

17. 硬件事件跟踪

使用 ETW（Event Tracing for Windows）来跟踪硬件事件：

```c
// 定义事件提供者
#define WPP_CONTROL_GUIDS \
    WPP_DEFINE_CONTROL_GUID( \
        MyDriverTraceGuid, (12345678-1234-1234-1234-123456789ABC), \
        WPP_DEFINE_BIT(MYDRIVER_ALL_INFO) \
    )

// 使用跟踪宏
DoTraceMessage(MYDRIVER_ALL_INFO, "Hardware event occurred: %d", eventCode);
```

18. 驱动程序框架选择

根据需求选择合适的驱动程序框架：
- WDF（Windows Driver Framework）用于大多数现代驱动程序
- WDM（Windows Driver Model）用于需要更多底层控制的场景
- KMDF（Kernel-Mode Driver Framework）用于内核模式驱动
- UMDF（User-Mode Driver Framework）用于用户模式驱动

这些高级主题涵盖了 Windows 内核驱动程序与硬件交互的多个方面。正确使用这些技术可以开发出高效、安全、可靠的驱动程序。记住，内核模式编程需要极高的谨慎，因为错误可能导致系统不稳定或崩溃。始终遵循 Microsoft 提供的最佳实践和安全指南，并进行彻底的测试和验证。:

19. 直接 I/O 与缓冲 I/O

在处理用户模式和内核模式之间的数据传输时,可以选择直接 I/O 或缓冲 I/O:

```c
// 直接 I/O
IRP_MJ_READ:
    if (irpSp->Parameters.Read.Length != 0) {
        status = WdfRequestRetrieveOutputWdmMdl(Request, &mdl);
        if (!NT_SUCCESS(status)) {
            goto Exit;
        }
        buffer = MmGetSystemAddressForMdlSafe(mdl, NormalPagePriority | MdlMappingNoExecute);
        if (!buffer) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
        // 直接从设备读取到 buffer
    }

// 缓冲 I/O
IRP_MJ_WRITE:
    status = WdfRequestRetrieveInputBuffer(Request, sizeof(ULONG), &buffer, &bufferLength);
    if (!NT_SUCCESS(status)) {
        goto Exit;
    }
    // 从 buffer 写入到设备
```

20. 硬件互斥锁 (Hardware Mutex)

对于某些复杂的硬件操作,可能需要使用硬件级别的互斥锁:

```c
NTSTATUS AcquireHardwareMutex(PDEVICE_EXTENSION DeviceExtension)
{
    ULONG attempts = 0;
    while (attempts < MAX_MUTEX_ATTEMPTS) {
        if (READ_REGISTER_ULONG(&DeviceExtension->Registers->MutexStatus) == 0) {
            WRITE_REGISTER_ULONG(&DeviceExtension->Registers->MutexLock, 1);
            KeMemoryBarrier(); // 确保写操作完成
            if (READ_REGISTER_ULONG(&DeviceExtension->Registers->MutexStatus) == 1) {
                return STATUS_SUCCESS;
            }
        }
        KeStallExecutionProcessor(100); // 等待 100 微秒
        attempts++;
    }
    return STATUS_TIMEOUT;
}
```

21. 硬件时钟同步

某些驱动可能需要与硬件时钟同步:

```c
LARGE_INTEGER systemTime, localTime;
ULONG64 hardwareTime;

KeQuerySystemTime(&systemTime);
ExSystemTimeToLocalTime(&systemTime, &localTime);

hardwareTime = READ_REGISTER_ULONG64(&DeviceExtension->Registers->HardwareTimer);

// 计算并存储偏移
DeviceExtension->TimeOffset = localTime.QuadPart - hardwareTime;
```

22. 内存池标记

使用唯一的内存池标记来跟踪驱动程序的内存分配:

```c
#define MYDRIVER_POOL_TAG 'MYDV'

PVOID buffer = ExAllocatePoolWithTag(NonPagedPool, size, MYDRIVER_POOL_TAG);
if (buffer == NULL) {
    // 处理内存分配失败
}

// 使用完毕后
ExFreePoolWithTag(buffer, MYDRIVER_POOL_TAG);
```

23. 硬件错误恢复

实现硬件错误恢复机制:

```c
NTSTATUS RecoverFromHardwareError(PDEVICE_EXTENSION DeviceExtension)
{
    NTSTATUS status;

    // 重置硬件
    WRITE_REGISTER_ULONG(&DeviceExtension->Registers->ControlRegister, HARDWARE_RESET_VALUE);
    KeStallExecutionProcessor(1000); // 等待 1 毫秒

    // 重新初始化硬件
    status = InitializeHardware(DeviceExtension);
    if (!NT_SUCCESS(status)) {
        // 记录错误并可能禁用设备
        return status;
    }

    // 恢复中断
    status = WdfInterruptEnable(DeviceExtension->Interrupt);
    if (!NT_SUCCESS(status)) {
        // 处理中断启用失败
        return status;
    }

    return STATUS_SUCCESS;
}
```

24. 硬件性能计数器

利用硬件性能计数器进行性能分析:

```c
LARGE_INTEGER performanceFrequency;
LARGE_INTEGER startTime, endTime;
ULONG64 elapsedMicroseconds;

KeQueryPerformanceCounter(&startTime);

// 执行需要计时的硬件操作

KeQueryPerformanceCounter(&endTime);
KeQueryPerformanceFrequency(&performanceFrequency);

elapsedMicroseconds = (endTime.QuadPart - startTime.QuadPart) * 1000000 / performanceFrequency.QuadPart;

KdPrint(("Operation took %llu microseconds\n", elapsedMicroseconds));
```

25. 动态加载驱动程序

实现动态加载和卸载功能,以支持热插拔设备:

```c
NTSTATUS
DriverEntry(
    _In_ PDRIVER_OBJECT  DriverObject,
    _In_ PUNICODE_STRING RegistryPath
)
{
    WDF_DRIVER_CONFIG config;
    NTSTATUS status;

    WDF_DRIVER_CONFIG_INIT(&config, EvtDeviceAdd);
    config.EvtDriverUnload = EvtDriverUnload;

    status = WdfDriverCreate(DriverObject,
                             RegistryPath,
                             WDF_NO_OBJECT_ATTRIBUTES,
                             &config,
                             WDF_NO_HANDLE);

    return status;
}

VOID
EvtDriverUnload(
    _In_ WDFDRIVER Driver
)
{
    // 清理资源,停止所有设备
}
```

26. 远程调试

配置内核调试器进行远程调试:

```
bcdedit /debug on
bcdedit /dbgsettings serial debugport:1 baudrate:115200
```

27. 驱动程序验证工具

使用 Driver Verifier 和其他工具来验证驱动程序:

```
verifier /standard /driver MyDriver.sys
```

这些高级主题涵盖了更多 Windows 内核驱动程序与硬件交互的复杂方面。正确实现这些技术可以显著提高驱动程序的性能、可靠性和安全性。然而,这些操作通常涉及底层系统交互,需要深入理解 Windows 内核架构和硬件工作原理。在实际开发中,应当谨慎使用这些技术,并进行充分的测试和验证。