windows驱动开发-PCI和中断(二)

最新推荐文章于 2024-05-16 00:51:31 发布
最新推荐文章于 2024-05-16 00:51:31 发布
阅读量1.7k 收藏 48
点赞数 50
分类专栏： windows平台WDM驱动开发 文章标签： windows 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72813396/article/details/138173342
版权

谈到中断使用PCI总线来作为例子是最合适的，在Windows发展过程中，PCI作为最成功的底层总线，集成了大量的外设，不夸张的说，目前PCI几乎是唯一的总线选择，故大部分情况下，只有PCI设备驱动程序会遇到需要使用中断的情况。

PCI的升级版本是PCIe，但是在协议上，PCIe兼容PCI总线，在编程上，这两者几乎一致，PCIe兼容了PCI的结构和定义，以至于仅看代码很难理解这些知识，这个文档推迟了很久，是因为我还需要一些PCI方面的文档。

直接架构于PCI总线的设备类型包括: USB总线、1394总线、网络适配器、显示适配器等等，PCI可能目前最广泛的总线体系，这套体系不仅仅是软件也是硬件。

PCI总线最早采用的中断机制是INTx，这是基于边带信号的。后续的PCI/PCI-X版本，为了消除边带信号，降低系统的硬件设计复杂度，逐渐采用了MSI/MSI-X的中断机制。INTx一般被称为传统的（Legacy）PCI中断机制，MSI和MSIX中断则属于PCIE后来使用的中断方式。

注意: 由于PCI和PCIe是前向兼容的，所以在下面的讨论中，讨论PCI就是指PCIe。

PCI配置空间

PCI配置空间是PCI（Peripheral Component Interconnect）设备特有的一个物理空间，它支持即插即用功能，允许操作系统自动配置PCI设备的参数。PCI配置空间总长度为256个字节，分为两部分：

配置首部：前64个字节的配置空间称为配置头，对于所有设备都一样，主要功能是用来识别设备、定义主机访问PCI卡的方式（I/O访问或存储器访问，以及中断信息）；
本地配置空间：其余的192个字节称为本地配置空间，主要定义卡上局部总线的特性、本地空间基地址及范围等；

PCI分为两种，一种成为PCI设备，另一种则是PCI桥，PCI设备容易理解，PCI桥则是用于将几个PCI总线连接起来的，一般认为每个PCI桥上可以有多个PCI设备。它们都使用相同的首部，不过PCI设备的首部称为type 0，PCI桥则是type 1，不过，遗憾的是，PCI的配置空间实际上是0x0或者0x81，位于PCI配置空间的14字节。

学习PCI最好实际看看PCI的配置空间，下图是我截取我系统上的PCI网卡的配置空间图；:

同样的PCI桥的配置空间如下:

在后续的文档中会详细解释这部分。 遗憾的是，我无法直接修改PCI的中断寄存器，无法演示两种中断模式。

INTx中断

在设备早期的开发中，很可能采用这种方式的中断，但是这种有边带信号触发的中断，有许多缺点: 系统其实无法准确分辨是PCI桥中具体哪一个设备引发的中断，需要调用所有的中断处理程序、系统每次收到中断的时候，数据其实并未准备好；每个设备最多有4个引脚可以触发传统中断。

但是无论如何，这种中断方式在硬件体系设计的早期是非常方便的，设备设计的早些版本很容易触发一个INTx中断，从而传输数据，从INTx中断升级到MSIX中断非常简单，并且对于主机侧来说，代码改动并不算太复杂，也不会改变程序结构。

目前的PCIe设备之间的中断信息传输中使用的并非边带信号INTx，而是基于消息(Message)的。其中Assert_INTx消息表示INTx信号的下降沿；Dessert_INTx消息表示INTx信号的上升沿。当发送这两种消息时，PCIe设备还会将配置空间的相关中断状态bit的值也进行更新。接收中断的物理设备的驱动程序会注册一个或多个中断服务例程， ISR为中断提供服务。 系统每次收到该中断时都会调用 ISR。

当驱动程序收到 IRP_MN_START_DEVICE 请求时，驱动程序将可以处理 IO_STACK_LOCATION 结构的 Parameters.StartDevice.AllocatedResources 和 Parameters.StartDevice.AllocatedResourcesTranslated 成员中的原始中断和已转换的硬件资源。 为了连接其中断，驱动程序使用 AllocatedResourcesTranslated.List.PartialResourceList.PartialDescriptors[] 中的资源。 驱动程序必须扫描部分描述符数组中 CmResourceTypeInterrupt 类型的资源。

如果驱动程序为 SpinLock 提供存储，则必须先调用 KeInitializeSpinLock ，然后才能将其中断旋转锁传递给 IoConnectInterrupt。

从成功调用 IoConnectInterrupt 返回后，如果在驱动程序的设备上启用了中断，或者 ShareVector 设置为 TRUE，则可以调用调用方 ISR。 在 IoConnectInterrupt 返回之前，驱动程序不得启用中断。

注意: 原始中断和已经分配的中断都是系统提供的，一般都会存储它们来为后面的一系列操作做准备。

有两个中断函数，不过先介绍第一个中断函数:

NTSTATUS IoConnectInterrupt(
  [out]          PKINTERRUPT       *InterruptObject,
  [in]           PKSERVICE_ROUTINE ServiceRoutine,
  [in, optional] PVOID             ServiceContext,
  [in, optional] PKSPIN_LOCK       SpinLock,
  [in]           ULONG             Vector,
  [in]           KIRQL             Irql,
  [in]           KIRQL             SynchronizeIrql,
  [in]           KINTERRUPT_MODE   InterruptMode,
  [in]           BOOLEAN           ShareVector,
  [in]           KAFFINITY         ProcessorEnableMask,
  [in]           BOOLEAN           FloatingSave
);
  • [out] InterruptObject: 指向指向一组中断对象的指针的驱动程序提供的存储地址的指针。 此指针必须在后续调用 KeSynchronizeExecution 中传递;
  • [in] ServiceRoutine: 指向驱动程序提供的 InterruptService 例程的入口点的指针;
  • [in, optional] ServiceContext: 指向驱动程序确定的上下文的指针，该上下文将在调用时提供给 InterruptService 例程。 ServiceContext 区域必须位于驻留内存中：在驱动程序创建的设备对象的设备扩展中、驱动程序创建的控制器对象的控制器扩展中，或位于设备驱动程序分配的非分页池中;
  • [in, optional] SpinLock:指向初始化的旋转锁的指针，驱动程序为其提供存储，该锁将用于同步对由其他驱动程序例程共享的驱动程序确定数据的访问。 如果 ISR 处理多个向量或驱动程序有多个 ISR，则此参数是必需的。 否则，驱动程序无需为中断旋转锁分配存储，并且输入指针为 NULL;
  • [in] Vector: 指定在CM_PARTIAL_RESOURCE_DESCRIPTOR的 u.Interrupt.Vector 成员处的中断资源中传递的中断向量;
  • [in] Irql: 指定在 CM_PARTIAL_RESOURCE_DESCRIPTOR 的 u.Interrupt.Level 成员处的中断资源中 传递的 DIRQL;
  • [in] SynchronizeIrql: 指定运行 ISR 的 DIRQL。 如果 ISR 处理多个中断向量或驱动程序具有多个 ISR，则此值必须是每个中断资源中 u.Interrupt.Level 传递的 Irql 值的最高值。 否则， Irql 和 SynchronizeIrql 值是相同的;
  • [in] InterruptMode: 指定设备中断是 LevelSensitive 还是 Latched;
  • [in] ShareVector: 指定中断向量是否可共享;
  • [in] ProcessorEnableMask: 指定一个 KAFFINITY 值，该值表示此平台中设备中断可能发生的处理器集。 此值在 u.Interrupt.Affinity 处的中断资源中传递;
  • [in] FloatingSave: 指定在驱动程序的设备中断时是否保存浮点堆栈。 对于基于 x86 和基于 Itanium 的平台，此值必须设置为 FALSE; 

 中断例程函数原型如下:

KSERVICE_ROUTINE KserviceRoutine;

BOOLEAN KserviceRoutine(
  [in] _KINTERRUPT *Interrupt,
  [in] PVOID ServiceContext
)
{...}

 下面我们从一个实际的案例来看中断:

NTSTATUS
NICMapHWResources(
    __in PFDO_DATA FdoData,
    __in PIRP Irp
    )
{
    PCM_PARTIAL_RESOURCE_DESCRIPTOR resourceTrans;
    PCM_PARTIAL_RESOURCE_LIST       partialResourceListTranslated;
    PIO_STACK_LOCATION              stack;
    ULONG                           i;
    NTSTATUS                        status = STATUS_SUCCESS;
    DEVICE_DESCRIPTION              deviceDescription;
    ULONG                           MaximumPhysicalMapping;
    PDMA_ADAPTER                    DmaAdapterObject;
    ULONG                           maxMapRegistersRequired, miniMapRegisters;
    ULONG                           MapRegisters;
    BOOLEAN bResPort = FALSE, bResInterrupt = FALSE, bResMemory = FALSE;
    ULONG                           numberOfBARs = 0;
#if defined(DMA_VER2) // To avoid  unreferenced local variables error
    ULONG                           SGMapRegsisters;
    ULONG                           ScatterGatherListSize;
#endif

    stack = IoGetCurrentIrpStackLocation (Irp);

    PAGED_CODE();

    if (NULL == stack->Parameters.StartDevice.AllocatedResourcesTranslated) {
        status = STATUS_DEVICE_CONFIGURATION_ERROR;
        goto End;
    }

    partialResourceListTranslated = &stack->Parameters.StartDevice.\
                      AllocatedResourcesTranslated->List[0].PartialResourceList;

    resourceTrans = &partialResourceListTranslated->PartialDescriptors[0];

    // 此处我们可以遍历所有IRP提供的硬件资源，一般是寄存器、端口、中断这三类
    for (i = 0;
         i < partialResourceListTranslated->Count;
         i++, resourceTrans++) {

        switch (resourceTrans->Type) {

        case CmResourceTypePort:

            numberOfBARs++;

            DebugPrint(LOUD, DBG_INIT,
                "I/O mapped CSR: (%x) Length: (%d)\n",
                resourceTrans->u.Port.Start.LowPart,
                resourceTrans->u.Port.Length);

            if(numberOfBARs != 2) {
                DebugPrint(ERROR, DBG_INIT, "I/O mapped CSR is not in the right order\n");
                status = STATUS_DEVICE_CONFIGURATION_ERROR;
                goto End;
            }


            FdoData->IoBaseAddress = ULongToPtr(resourceTrans->u.Port.Start.LowPart);
            FdoData->IoRange = resourceTrans->u.Port.Length;

            FdoData->ReadPort = NICReadPortUShort;
            FdoData->WritePort = NICWritePortUShort;

            bResPort = TRUE;
            FdoData->MappedPorts = FALSE;
            break;

        case CmResourceTypeMemory:

            numberOfBARs++;

            if(numberOfBARs == 1) {
                DebugPrint(LOUD, DBG_INIT, "Memory mapped CSR:(%x:%x) Length:(%d)\n",
                                        resourceTrans->u.Memory.Start.LowPart,
                                        resourceTrans->u.Memory.Start.HighPart,
                                        resourceTrans->u.Memory.Length);

                ASSERT(resourceTrans->u.Memory.Length == 0x1000);
                FdoData->MemPhysAddress = resourceTrans->u.Memory.Start;
                FdoData->CSRAddress = MmMapIoSpace(
                                                resourceTrans->u.Memory.Start,
                                                NIC_MAP_IOSPACE_LENGTH,
                                                MmNonCached);
                if(FdoData->CSRAddress == NULL) {
                    DebugPrint(ERROR, DBG_INIT, "MmMapIoSpace failed\n");
                    status = STATUS_INSUFFICIENT_RESOURCES;
                    goto End;
                }
                DebugPrint(LOUD, DBG_INIT, "CSRAddress=%p\n", FdoData->CSRAddress);

                bResMemory = TRUE;

            } else if(numberOfBARs == 2){

                DebugPrint(LOUD, DBG_INIT,
                    "I/O mapped CSR in Memory Space: (%x) Length: (%d)\n",
                    resourceTrans->u.Memory.Start.LowPart,
                    resourceTrans->u.Memory.Length);


                FdoData->IoBaseAddress = MmMapIoSpace(
                                                resourceTrans->u.Memory.Start,
                                                resourceTrans->u.Memory.Length,
                                                MmNonCached);
                if(FdoData->IoBaseAddress == NULL) {
                       DebugPrint(ERROR, DBG_INIT, "MmMapIoSpace failed\n");
                       status = STATUS_INSUFFICIENT_RESOURCES;
                       goto End;
                }

                FdoData->ReadPort = NICReadRegisterUShort;
                FdoData->WritePort = NICWriteRegisterUShort;
                FdoData->MappedPorts = TRUE;
                bResPort = TRUE;

            } else if(numberOfBARs == 3){

                DebugPrint(LOUD, DBG_INIT, "Flash memory:(%x:%x) Length:(%d)\n",
                                        resourceTrans->u.Memory.Start.LowPart,
                                        resourceTrans->u.Memory.Start.HighPart,
                                        resourceTrans->u.Memory.Length);

            } else {
                DebugPrint(ERROR, DBG_INIT,
                            "Memory Resources are not in the right order\n");
                status = STATUS_DEVICE_CONFIGURATION_ERROR;
                goto End;
            }

            break;

        case CmResourceTypeInterrupt:

            ASSERT(!bResInterrupt);

            bResInterrupt = TRUE;
            //
            // 将所有中断特定信息保存在设备中
            // 因为我们稍后在电源暂停和恢复期间需要它来断开和连接
            //
            FdoData->InterruptLevel = (UCHAR)resourceTrans->u.Interrupt.Level;
            FdoData->InterruptVector = resourceTrans->u.Interrupt.Vector;
            FdoData->InterruptAffinity = resourceTrans->u.Interrupt.Affinity;

            if (resourceTrans->Flags & CM_RESOURCE_INTERRUPT_LATCHED) {

                FdoData->InterruptMode = Latched;

            } else {

                FdoData->InterruptMode = LevelSensitive;
            }


            ASSERT(FdoData->InterruptMode == LevelSensitive);

            DebugPrint(LOUD, DBG_INIT,
                "Interrupt level: 0x%0x, Vector: 0x%0x, Affinity: 0x%x\n",
                FdoData->InterruptLevel,
                FdoData->InterruptVector,
                (UINT)FdoData->InterruptAffinity); // casting is done to keep WPP happy
            break;

        default:

            DebugPrint(LOUD, DBG_INIT, "Unhandled resource type (0x%x)\n",
                                        resourceTrans->Type);
            break;

        }
    }

    if (!(bResPort && bResInterrupt && bResMemory)) {
        status = STATUS_DEVICE_CONFIGURATION_ERROR;
        goto End;
    }

    NICDisableInterrupt(FdoData);

    IoInitializeDpcRequest(FdoData->Self, NICDpcForIsr);

    status = IoConnectInterrupt(&FdoData->Interrupt,
                              NICInterruptHandler,
                              FdoData,                   // ISR Context
                              NULL,
                              FdoData->InterruptVector,
                              FdoData->InterruptLevel,
                              FdoData->InterruptLevel,
                              FdoData->InterruptMode,
                              TRUE, // shared interrupt
                              FdoData->InterruptAffinity,
                              FALSE);
    if (status != STATUS_SUCCESS)
    {
        DebugPrint(ERROR, DBG_INIT, "IoConnectInterrupt failed %x\n", status);
        goto End;
    }

    MP_SET_FLAG(FdoData, fMP_ADAPTER_INTERRUPT_IN_USE);


    RtlZeroMemory(&deviceDescription, sizeof(DEVICE_DESCRIPTION));


#if defined(DMA_VER2)
    deviceDescription.Version = DEVICE_DESCRIPTION_VERSION2;
#else
    deviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
#endif

    deviceDescription.Master = TRUE;
    deviceDescription.ScatterGather = TRUE;
    deviceDescription.Dma32BitAddresses = TRUE;
    deviceDescription.Dma64BitAddresses = FALSE;
    deviceDescription.InterfaceType = PCIBus;

    miniMapRegisters = ((NIC_MAX_PACKET_SIZE * 2 - 2) / PAGE_SIZE) + 2;

    maxMapRegistersRequired = FdoData->NumTcb * NIC_MAX_PHYS_BUF_COUNT;

    MaximumPhysicalMapping = (maxMapRegistersRequired-1) << PAGE_SHIFT;
    deviceDescription.MaximumLength = MaximumPhysicalMapping;

    DmaAdapterObject = IoGetDmaAdapter(FdoData->UnderlyingPDO,
                                        &deviceDescription,
                                        &MapRegisters);
    if (DmaAdapterObject == NULL)
    {
        DebugPrint(ERROR, DBG_INIT, "IoGetDmaAdapter failed\n");
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto End;
    }

    if(MapRegisters < miniMapRegisters) {
        DebugPrint(ERROR, DBG_INIT, "Not enough map registers: Allocated %d, Required %d\n",
                                        MapRegisters, miniMapRegisters);
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto End;
    }

    FdoData->AllocatedMapRegisters = MapRegisters;

    FdoData->NumTcb = MapRegisters/miniMapRegisters;

    FdoData->NumTcb = min(FdoData->NumTcb, NIC_MAX_TCBS);

    DebugPrint(TRACE, DBG_INIT, "MapRegisters Allocated %d\n", MapRegisters);
    DebugPrint(TRACE, DBG_INIT, "Adjusted TCB count is %d\n", FdoData->NumTcb);

    FdoData->DmaAdapterObject = DmaAdapterObject;
    MP_SET_FLAG(FdoData, fMP_ADAPTER_SCATTER_GATHER);

#if defined(DMA_VER2)

    status = DmaAdapterObject->DmaOperations->CalculateScatterGatherList(
                                            DmaAdapterObject,
                                            NULL,
                                            0,
                                            MapRegisters * PAGE_SIZE,
                                            &ScatterGatherListSize,
                                            &SGMapRegsisters);


    ASSERT(NT_SUCCESS(status));
    ASSERT(SGMapRegsisters == MapRegisters);
    if (!NT_SUCCESS(status))
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto End;
    }

    FdoData->ScatterGatherListSize = ScatterGatherListSize;

#endif

    FdoData->AllocateCommonBuffer =
                   *DmaAdapterObject->DmaOperations->AllocateCommonBuffer;
    FdoData->FreeCommonBuffer =
                   *DmaAdapterObject->DmaOperations->FreeCommonBuffer;
End:
    return status;
}

可以看到，在上面的例子中，我们会调用IoConnectInterrupt函数来连接中断。

这里的代码中有一部分遗憾，由于没有使用自旋锁，所以调用SpinLock之前需要初始化自旋锁这一点并未体现。

还有另外一个遗憾就是，中断本身适合处理器相关的，但是IoConnectInterrupt的返回值中，可能出现STATUS_INVALID_PARAMETER，这个错误的本质是没有指定合适的处理器，但是它的返回值上没有说明这一点，参数ProcessorEnableMask指的就是处理器组，它的解释如下: 

KAFFINITY 类型在 32 位版本的 Windows 上为 32 位，在 64 位版本的 Windows 上为 64 位。

如果组包含 n 个逻辑处理器，则处理器的编号从 0 到 n-1。 组中的处理器编号 i 由关联掩码中的位 i 表示，其中 i 在 0 到 n-1 的范围内。 与逻辑处理器不对应的关联掩码位始终为零。

例如，如果 KAFFINITY 值标识组中的活动处理器，如果处理器处于活动状态，则处理器的掩码位为 1;如果处理器不处于活动状态，则为0。

关联掩码中的位数确定组中逻辑处理器的最大数目。 对于 64 位版本的 Windows，每个组的最大处理器数为 64。 对于 32 位版本的 Windows，每个组的最大处理器数为 32。 调用 KeQueryMaximumProcessorCountEx 例程以获取每个组的最大处理器数。 此数字取决于多处理器系统的硬件配置，但永远不能超过 64 位和 32 位版本的 Windows 分别设置的固定 64 处理器和 32 处理器限制。

GROUP_AFFINITY 结构包含一个相关性掩码和一个组编号。 组号标识应用相关性掩码的组。

禁止和启用中断

和我们的直觉相反，禁止和启用中断非常频繁，这有几个原因:

首先，中断等级直接等于代码运行等级，windows明确规定中断不会被同级别的中断打断，只能被更高级别的中断打断；其次，边带信号可以理解为引脚上拉这种操作，这对于硬件那边也很好设计；最后，中断可以共享，因为系统内可以使用的中断向量只有两百多个，但是明显系统需要使用的中断远多于这个，故共享中断的时候，也需要注意避免中断之间的干扰。

中断的禁用也非常简单:

__inline VOID
NICDisableInterrupt(
    __in PFDO_DATA FdoData
    )
{
   FdoData->CSRAddress->ScbCommandHigh = SCB_INT_MASK;
}

KSYNCHRONIZE_ROUTINE NICEnableInterrupt;
    
__inline 
BOOLEAN
NICEnableInterrupt(
    PVOID Context
    )
{
    PFDO_DATA FdoData = Context;
    FdoData->CSRAddress->ScbCommandHigh = 0;
    return TRUE;
}

此处解释一下， CSRAddress->ScbCommandHigh是已经映射进系统空间的中断寄存器的地址，对它修改之后，系统会检测到这种行为并设置，硬件那边在发起中断之前可以查询这个寄存器来决定要不要中断。

我们由此也能知道什么时候禁用和启用中断:

在中断例程正在执行时；

系统进入深度睡眠(< S4)同时设备不需要唤醒时;

设备禁用和启用；设备进入D3同时不需要唤醒时；

sului
关注
  • 50
    点赞
  • 踩
  • 48
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows无线网卡驱动的开发.zip
10-24
在Windows系统中，驱动开发通常遵循Windows Driver Model (WDM)、Kernel-Mode Driver Framework (KMDF)或User-Mode Driver Framework (UMDF)。 1. **WDM（Windows Driver Model）**：这是一种传统的驱动模型，适用...
windows驱动开发技术详解-part2
07-06
本书由浅入深、循序渐进地介绍了Windows驱动程序的开发方法与调试技巧。本书共分23章，内容涵盖了 Windows操作系统的基本原理、NT驱动程序与WDM驱动程序的构造、驱动程序中的同步异步处理方法、驱 动程序中即插即...
驱动开发代码研读
张公子的博客
12-02 4334
XDMA源码解读
PCIe扫盲——基于WinDriver快速开发PCIe驱动简明教程
kunkliu的博客
07-09 6996
转载地址：http://blog.chinaaet.com/justlxy/p/5100064256 本文将简要介绍如何使用Jungo公司的WinDriver工具快速开发PCI Express设备驱动，以及相关注意事项。本文所使用的的测试平台信息如下： ※操作系统：Win7 SP1 64bit ※驱动开发工具：WinDriver12.1 ※应用程序开发工具：MSVS20...
【紫光同创PCIE教程】——使用官方驱动在Windows下进行DMA读写操作/PIO读写操作
MYMINIEYE的博客
11-30 1114
紫光同创官方主推的是在linux系统下开发驱动和上层软件，相应地，官方提供了在linux一个基于GTK+2.0的PCIE测试平台，该平台能够很好去操作官方生成的例程。官方也提供了一个Windows的驱动例程，该例程能够完成PCIE的DMA读写操作和PIO内存读写操作，但是该驱动并未完全适配IP生成的官方例程，官方提供另一份的FPGA的工程与之适配。最后简单声明一下，更改驱动只是适配紫光同创IP生成的例程，把IP自带例程的DMA机制通信成功起来，当然也可以去更改IP生成例程DMA的逻辑设计来适配原来的驱动。
windows驱动开发-PCI讨论(一)
最新发布
苏洛坷的博客
05-16 905
PCI技术
PCIE学习系列 三（PCIE中断）
qq_42208449的博客
09-07 3105
在PCIe中有三种中断方式，分别是INTx、MSI、MSI-X，下面将对三种中断类型分别进行描述。PCIe有三种中断,分别为INTx中断，MSI中断，MSI-X中断，在PCI总线中，所有需要提交中断请求的设备，必须能够通过INTx引脚提交中断请求，而MSI机制是一个可选机制。
PCI设备WINDOWS驱动程序的开发
02-18
开发PCI设备的Windows驱动程序是一项复杂的工作，需要对硬件、操作系统内核以及驱动编程有深入理解。选择合适的硬件接口芯片和开发工具，结合对驱动程序模式的理解，可以有效地完成驱动程序的编写，确保PCI设备在...
Windows驱动开发技术详解的光盘-part1
07-06
用实例详细讲解PCI、USB、虚拟串口、虚拟摄像头、SDIO等驱动程序的开发，归纳了多种调试驱动程序的高级技巧，如用WinDBG和VMWARE软件对驱动进行源码级调试，深入Windows操作系统的底层和内核，透析Windows驱动开发的...
pci9054驱动程序(包括Windows和vxworks)
03-27
3. **Windows驱动开发**：在Windows环境下，驱动程序通常遵循WDK（Windows Driver Kit）提供的框架，使用DDK（Driver Development Kit）进行开发。对于PCI9054，Windows驱动可能包括初始化、设备枚举、中断处理、DMA...
Windows中断处理过程.pdf
11-10
初步介绍了windows系统中断处理的知识
WDF pci驱动开发的若干总结
lixiaojun216的专栏
03-12 908
最近在调试一套windows下的PCIE板卡驱动，采用的是WDF的驱动框架，驱动实现了阻塞式的读操作、写操作和IOCTL等三类操作，在实际的应用过程中，遇到了如下问题： 1、驱动加载后，PCI分配的IO和Mem对应地址内的内容完全变成了0xFF，无法进行驱动的配置； 2、应用程序中，开启两个任务分别进行设备的读和写的操作，发现写的任务也会进行阻塞，必须等到read返回之后才能调度，导致没法并行处理。 针对第一个问题，同样的程序在win xp上可以正常运行，win7 32和64位的版本均不能运行，.
Windows中断那些事儿
weixin_30794499的博客
05-18 438
搞内核研究的经常对中断这个概念肯定不陌生，经常我们会接触很多与中断相关的术语，按照软件和硬件进行分类： 硬件CPU相关： IRQ、IDT、cli&sti 软件操作系统相关： APC、DPC、IRQL 一直以来对中断这一部分内容弄的一知半解，操作系统和CPU之间如何协同工作也是很模糊。最近花了点时间认真把这块知识进行了梳理，不当之处，还请高手指出，...
Windows驱动开发系列之二：WDM设备驱动开发入门
11-16
我将带领大家学习WDM驱动开发，包括重要的理论与实践。我们逐步深入，在系列一的基础上慢慢推进，开始学习WDM驱动模型，包括重要的IRP及派遣函数，具体章节包括：1）PNP即插即用管理2）电源管理3）IO端口管理4）PCI配置空间管理 Windows内核开发寄语：1、Windows内核非常复杂，相关图书和课程都很少，让很多初学者望而生畏；没关系，我带领大家别有兴致地来领略Windows内核的神秘，解开面纱，层层深入。2、本书以Windows10x64位基准，所有程序都编译、运行在Vmware的Win10x64位机器上。vs2019+wdk3、内核学习并不可怕，授人以鱼不如授人以渔，艺多不压身，学习能提升人的综合能力，尤其是核心技术。
Windows驱动——利用WinDriver开发PCI设备驱动程序
YBAdiam的博客
05-17 4821
摘要 WinDriver是Jungo公司出版的一个设备驱动程序开发组件，它可以大大加速PCI设备驱动程序的开发。作者在实际的项目中采用了WinDriver来开发设备驱动程序，取得了相当好的运行效果。从目前国内的资料上来看，大多数设计人员还是在用DDK、Wtools开发设备驱动程序，因而作者觉得有必要向大家介绍与推荐这个软件。 WinDriver是一套设备驱动程序开发组...
Windows系统结构的中断（1）
チンポー的博客
03-14 2011
中断：异步事件（可以在任何时候发生），且与处理器当前正在执行的任务毫无关系。主要由I/O设备、处理器时钟、定时器产生，可启用或禁用。异常：同步事件，一个特殊指令执行的结果。陷阱：当异常或中断发生时，处理器捕捉到一个执行线程，并且将控制权转移到操作系统中某一固定地址处。在Windows中，处理器会将控制权转给陷阱处理器（指某个特定的中断或异常相关联的函数）。硬件中断处理：在支持Windows的硬件平台
windows内核情景分析---中断处理
maomao171314的专栏
04-04 1805
中断处理 每个cpu有一张中断表,简称IDT。 IDT的整体布局：【异常->空白->5系->硬】（推荐采用7字口诀的方式重点记忆） 异常：前20个表项存放着各个异常的描述符（IDT表不仅可以放中断描述符，还放置了所有异常的异常处理描述符，0x00-0x13） 保留：0x14-0x1F,忽略这块号段 空白：接下来存放一组空闲的保留项(0x20-0x29)，供系统和程序员自己分配注册使用
PCI-E配置MSI中断流程解析 分类： windows驱动程序WDM...
06-08
很抱歉，作为一个语言模型AI，我并不会编写具体的代码或者进行硬件方面的配置。不过，我可以为您提供一些相关的知识和概念，以便您更好地理解PCI-E配置和MSI中断流程。 PCI-E（Peripheral Component Interconnect Express）是一种用于计算机总线的高速串行通信技术，它可以用于连接各种外部设备，如显卡、声卡、网卡等。PCI-E配置涉及到的主要内容包括设备的初始化、设备寻址、资源分配等。 MSI（Message Signaled Interrupt）是一种新型的中断处理方式，它可以取代传统的IRQ（Interrupt Request）中断处理方式，可以提高系统的性能和可靠性。MSI中断流程包括向设备发送中断消息、设备响应中断消息、中断处理程序执行等步骤。 如果您需要具体的代码实现或者硬件配置方面的帮助，建议您向专业的硬件工程师或者软件开发人员咨询。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值