IO_Card 驱动

超、凢脫俗 2022-08-03 00:11 328阅读 0赞 
  1. 公司别人写的。
  3. </pre><pre name="code" class="cpp">/*
  4. IO_Card 驱动 
  5. 1、系统找到DriverEntry()函数，初始化驱动程序。
  6. 2、系统调用AddDevice例程添加设备对象。
  7. 3、FDO收到IRP_MN_START_DEVICE IRP，将其设置完成例程（实际设置在下个IO堆栈）后传递给PDO。接着FDO等待同步。（实际上PDO完成资源分配）
  8. 4、当PDO完成IRP_MN_START_DEVICE IRP，设备堆栈回滚时。执行完成例程，并将IRP再次交给FDO。
  9. 5、FDO根据IRP提供的IO堆栈得到设备资源，并完成例程。
  10. 6、等待各种IRP和中断
  11.     6.1、中断（主要用于操作）
  12.     6.2、PNP IRP（主要用于配置）
  13.     6.3、普通IRP（主要用于操作）
  14. 7、当驱动处理完IRP_MN_REMOVE_DEVICE例程后，系统调用HelloWDMUnload例程完成后续工作。
  15. */
  17. #include <initguid.h>
  18. #include "Guid.h"
  19. #include "IO_Card.h"
  20. #include "Ioctls.h"
  22. #pragma INITCODE 
  23. // INIT指明该函数只用于初始化，用完后就释放。（节约内存）
  24. // 代码放在代码段，数据放在数据段。
  25. extern "C" NTSTATUS DriverEntry(
  26.                                 // IN、OUT和INOUT是空宏定义，主要起注释作用。
  27.                                 IN PDRIVER_OBJECT pDriverObject, // I/O管理器传递过来的驱动对象。
  28.                                 IN PUNICODE_STRING pRegistryPath // 驱动对象注册表路径。
  29.                                )
  30. // extern "C"用于在CPP模式下引用C代码，保证符号链接的正确性。
  31. {
  32.     KdPrint(("Enter DriverEntry\n")); // 调试信息打印函数，它只在check版本中生效。
  34.     pDriverObject->DriverExtension->AddDevice = IO_CardAddDevice; // 设置添加设备回调函数。
  35.     pDriverObject->MajorFunction[IRP_MJ_PNP] = IO_CardPnp; // 设置PNP IRP处理回调函数。
  36.     pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchControl; // 设置IO操作回调函数。 
  37.     pDriverObject->MajorFunction[IRP_MJ_CREATE] = IO_CardDispatchRoutine;
  38.     pDriverObject->MajorFunction[IRP_MJ_CLOSE] = IO_CardDispatchRoutine;
  39.     pDriverObject->MajorFunction[IRP_MJ_READ] = IO_CardDispatchRoutine;
  40.     pDriverObject->MajorFunction[IRP_MJ_WRITE] = IO_CardDispatchRoutine; // 设置缺省IRP处理回调函数。
  41.     pDriverObject->DriverUnload = IO_CardUnload; // 设置删除设备回调函数（实际上在PNP IRP中就被处理了）。
  43.     KdPrint(("Leave DriverEntry\n")); // 调试信息打印函数，它只在check版本中生效。
  44.     return STATUS_SUCCESS;
  45. }
  47. #pragma PAGEDCODE
  48. // IRQL优先级高的使用分页内存，反之使用非分页内存。（维持系统稳定性）
  49. // 代码放在代码段，数据放在数据段。
  50. NTSTATUS IO_CardAddDevice(
  51.                             // IN、OUT和INOUT是空宏定义，主要起注释作用。
  52.                             IN PDRIVER_OBJECT DriverObject, // I/O管理器传递过来的驱动对象。
  53.                             IN PDEVICE_OBJECT PhysicalDeviceObject // 从I/O管理器传递过来的物理设备对象。
  54.                           )
  55. { 
  56.     PAGED_CODE(); // 它会检查当前函数是否运行低于DISPATCH_LEVEL的中断请求级，如果等于或高于这个中断请求级，将产生一个断言。它只在check版本中生效。
  57.     KdPrint(("Enter IO_CardAddDevice\n")); // 调试信息打印函数，它只在check版本中生效。
  59.     NTSTATUS status;
  60.     PDEVICE_OBJECT fdo;
  62.     // 创建设备驱动。
  63.     status = IoCreateDevice(DriverObject,sizeof(DEVICE_EXTENSION),NULL,FILE_DEVICE_UNKNOWN,0,FALSE,&fdo);
  64.     // 是否创建成功。
  65.     if( !NT_SUCCESS(status))
  66.         return status;
  68.     PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)fdo->DeviceExtension; // 获取设备扩展对象的指针。
  69.     pdx->fdo = fdo; // 当前设备。
  70.     pdx->NextStackDevice = IoAttachDeviceToDeviceStack(fdo, PhysicalDeviceObject); // 附着FDO到PDO上，并且把返回的PDO记录在FDO的扩展对象中。
  72.     // 创建设备接口。（不能指定设备名）
  73.     status = IoRegisterDeviceInterface(PhysicalDeviceObject, &IO_CARD_DEVICE, NULL, &pdx->interfaceName);
  74.     if( !NT_SUCCESS(status))
  75.     {
  76.         IoDeleteDevice(fdo); // 失败则删除FDO。
  77.         return status;
  78.     }
  79.     IoSetDeviceInterfaceState(&pdx->interfaceName, TRUE); // 使设备名有效。
  80.     if( !NT_SUCCESS(status))
  81.     {
  82.         if( !NT_SUCCESS(status))
  83.         {
  84.             return status;
  85.         }
  86.     }
  87.     KdPrint(("%wZ\n",&pdx->interfaceName)); // 调试信息打印函数，它只在check版本中生效。
  89.     // 设置标志位。
  90.     fdo->Flags |= DO_BUFFERED_IO | DO_POWER_PAGABLE;
  91.     fdo->Flags &= ~DO_DEVICE_INITIALIZING;
  93.     KdPrint(("Leave IO_CardAddDevice\n")); // 调试信息打印函数，它只在check版本中生效。
  94.     return STATUS_SUCCESS;
  95. }        
  97. // 中断响应例程。
  98. BOOLEAN OnInterrupt(PKINTERRUPT InterruptObject, PDEVICE_EXTENSION pdx)
  99. {                        
  101.     // 关中断。
  102.     UCHAR HSR  = READ_PORT_UCHAR(pdx->portbase);
  103.     HSR = HSR | 0x04;
  104.     WRITE_PORT_UCHAR(pdx->portbase,HSR);
  105.     KdPrint(("==============interrupt!!!\n"));
  107.     // 恢复中断信号电平。
  108.     WRITE_REGISTER_UCHAR((PUCHAR)pdx->MemBar0+0x400000,0x10);
  109.     IoRequestDpc(pdx->fdo, NULL, pdx); // 中断处理标志，DPC处理事件。
  111.     return TRUE;
  112. }    
  114. #pragma PAGEDCODE
  115. // IRQL优先级高的使用分页内存，反之使用非分页内存。（维持系统稳定性）
  116. // 代码放在代码段，数据放在数据段。
  117. NTSTATUS InitMyPCI(IN PDEVICE_EXTENSION pdx,IN PCM_PARTIAL_RESOURCE_LIST list) // 主要用于将系统分配的资源初始化。
  118. {
  119.     PHYSICAL_ADDRESS portbase; // 端口物理地址。
  120.     BOOLEAN gotport = FALSE;
  122.     ULONG vector; // 中断向量。
  123.     KIRQL irql; // 中断请求级。
  124.     KINTERRUPT_MODE mode; // 中断模式。
  125.     KAFFINITY affinity; // CPU的亲缘关系。
  126.     BOOLEAN irqshare; // 是否共享中断。
  127.     BOOLEAN gotinterrupt = FALSE;
  129.     ULONG nres = list->Count; // 资源总数。
  130.     PCM_PARTIAL_RESOURCE_DESCRIPTOR resource = &list->PartialDescriptors[0];
  132.     // 每次循环获取一种资源。
  133.     for (ULONG i = 0; i < nres; ++i, ++resource)
  134.     {    
  135.         // 判断是何种资源。
  136.         switch(resource->Type)
  137.         {    
  138.             // I/O端口资源。
  139.             case CmResourceTypePort:
  140.                 // I/O端口地址。
  141.                 portbase = resource->u.Port.Start;
  142.                 // I/O端口地址长度。
  143.                 pdx->nports = resource->u.Port.Length;
  144.                 // 是否需要地址映射。
  145.                 pdx->mappedport = (resource->Flags & CM_RESOURCE_PORT_IO) == 0;
  146.                 // 表示已经得到I/O端口资源。
  147.                 gotport = TRUE;
  148.                 break;
  149.             // 物理内存资源。
  150.             case CmResourceTypeMemory:
  151.                 pdx->MemBar0 = (PUCHAR)MmMapIoSpace(resource->u.Memory.Start,resource->u.Memory.Length,MmNonCached);
  152.                 pdx->nMem0 = resource->u.Memory.Length;
  153.                 break;
  154.             // 中断资源。
  155.             case CmResourceTypeInterrupt:
  156.                 // 获得中断请求级。
  157.                 irql = (KIRQL) resource->u.Interrupt.Level;
  158.                 // 获得中断向量。
  159.                 vector = resource->u.Interrupt.Vector;
  160.                 // 获取CPU亲缘关系。
  161.                 affinity = resource->u.Interrupt.Affinity;
  162.                 // 获得中断模式。
  163.                 mode = (resource->Flags == CM_RESOURCE_INTERRUPT_LATCHED) ? Latched : LevelSensitive;
  164.                 // 判断是否需要共享中断。
  165.                 irqshare = resource->ShareDisposition == CmResourceShareShared;
  166.                 // 表示已经得到中断。
  167.                 gotinterrupt = TRUE;
  168.                 break;
  169.             default:
  170.                 KdPrint(("Unexpected I/O resource type %d\n", resource->Type));
  171.                 break;
  172.         }                
  173.     }                    
  174.     if (!(TRUE&& gotport&& gotinterrupt))
  175.     {
  176.         KdPrint((" Didn't get expected I/O resources\n"));
  177.         return STATUS_DEVICE_CONFIGURATION_ERROR;
  178.     }
  179.     // 判断是够需要I/O端口映射。（为了操作方便，把IO空间映射到MEM空间）
  180.     if (pdx->mappedport)
  181.     {
  182.         // 获得I/O端口地址。
  183.         pdx->portbase = (PUCHAR) MmMapIoSpace(portbase, pdx->nports, MmNonCached);
  184.         if (!pdx->mappedport)
  185.         {
  186.             KdPrint(("Unable to map port range %I64X, length %X\n", portbase, pdx->nports));
  187.             return STATUS_INSUFFICIENT_RESOURCES;
  188.         }
  189.     }                    
  190.     else
  191.         // 获得I/O端口地址。
  192.         pdx->portbase = (PUCHAR) portbase.QuadPart;
  194.     // 链接中断。（中断对象与中断响应例程链接）
  195.     NTSTATUS status = IoConnectInterrupt(&pdx->InterruptObject, (PKSERVICE_ROUTINE)OnInterrupt, (PVOID)pdx, NULL, vector, irql, irql, LevelSensitive, TRUE, affinity, FALSE);
  196.     if (!NT_SUCCESS(status))
  197.     {
  198.         KdPrint(("IoConnectInterrupt failed - %X\n", status));
  200.         if (pdx->portbase && pdx->mappedport)
  201.             MmUnmapIoSpace(pdx->portbase, pdx->nports);
  202.         pdx->portbase = NULL;
  204.         return status;
  205.     }
  207.     return STATUS_SUCCESS;    
  208. }
  210. #pragma LOCKEDCODE
  211. // IRQL优先级高的使用分页内存，反之使用非分页内存。（维持系统稳定性）
  212. // 代码放在代码段，数据放在数据段。
  213. NTSTATUS OnRequestComplete(PDEVICE_OBJECT junk, PIRP Irp, PKEVENT pev)
  214. {                    
  215.     KeSetEvent(pev, 0, FALSE); // 把IRP事件设置为完成。
  217.     return STATUS_MORE_PROCESSING_REQUIRED; // 再次完成IRP事件 。
  218. }
  220. #pragma PAGEDCODE
  221. // IRQL优先级高的使用分页内存，反之使用非分页内存。（维持系统稳定性）
  222. // 代码放在代码段，数据放在数据段。
  223. // 上层设备的完成例程设置在下层设备IO堆栈。
  224. NTSTATUS ForwardAndWait(PDEVICE_EXTENSION pdx, PIRP Irp)
  225. {                
  226.     PAGED_CODE(); // 它会检查当前函数是否运行低于DISPATCH_LEVEL的中断请求级，如果等于或高于这个中断请求级，将产生一个断言。它只在check版本中生效。
  228.     KEVENT event;
  229.     KeInitializeEvent(&event, NotificationEvent, FALSE); // 初始化事件，用于同步IPR。
  231.     IoCopyCurrentIrpStackLocationToNext(Irp); // 本层对IRP有所处理，故需将本层堆栈拷贝到下一层堆栈。（使下层设备处理环境一样）
  232.     // 设置完成例程。
  233.     IoSetCompletionRoutine(Irp,(PIO_COMPLETION_ROUTINE) OnRequestComplete,(PVOID) &event, TRUE, TRUE, TRUE);
  234.     //调用底层驱动，即PDO。
  235.     IoCallDriver(pdx->NextStackDevice, Irp);
  236.     //等待PDO完成。
  237.     KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
  239.     return Irp->IoStatus.Status;
  240. }
  242. #pragma PAGEDCODE
  243. NTSTATUS HandleStartDevice(PDEVICE_EXTENSION pdx, PIRP Irp)
  244. {
  245.     PAGED_CODE();
  246.     KdPrint(("Enter HandleStartDevice\n"));
  248.     // 转发IRP并等待（利用事件同步）返回，IRP_MN_START_DEVICE必须由PDO处理。
  249.     NTSTATUS status = ForwardAndWait(pdx,Irp);
  250.     if (!NT_SUCCESS(status))
  251.     {
  252.         Irp->IoStatus.Status = status;
  253.         IoCompleteRequest(Irp, IO_NO_INCREMENT);
  255.         return status;
  256.     }
  258.     // 得到当前堆栈。
  259.     PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(Irp);
  261.     // 从当前堆栈得到翻译信息。
  262.     PCM_PARTIAL_RESOURCE_LIST translated;
  263.     if (stack->Parameters.StartDevice.AllocatedResourcesTranslated)
  264.         translated = &stack->Parameters.StartDevice.AllocatedResourcesTranslated->List[0].PartialResourceList;
  265.     else
  266.         translated = NULL;
  268.     KdPrint(("Init the PCI card!\n"));
  269.     InitMyPCI(pdx,translated); // 获取设备资源。
  271.     // 完成IRP。
  272.     Irp->IoStatus.Status = STATUS_SUCCESS;
  273.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  275.     KdPrint(("Leave HandleStartDevice\n"));
  276.     return status;
  277. }
  279. #pragma PAGEDCODE
  280. // IRQL优先级高的使用分页内存，反之使用非分页内存。（维持系统稳定性）
  281. // 代码放在代码段，数据放在数据段。
  282. NTSTATUS DefaultPnpHandler(
  283.                             PDEVICE_EXTENSION pdx, // 扩展对象。
  284.                             PIRP Irp // IRP包对象。
  285.                           )
  286. {
  287.     PAGED_CODE(); // 它会检查当前函数是否运行低于DISPATCH_LEVEL的中断请求级，如果等于或高于这个中断请求级，将产生一个断言。它只在check版本中生效。
  288.     KdPrint(("Enter DefaultPnpHandler\n")); // 调试信息打印函数，它只在check版本中生效。
  290.     IoSkipCurrentIrpStackLocation(Irp); // 使IRP的IO堆栈指针后退一格，因为FDO没有对IRP处理，故不需要对其记录，将此堆栈留给PDO使用。（节约内存）
  292.     KdPrint(("Leave DefaultPnpHandler\n")); // 调试信息打印函数，它只在check版本中生效。
  293.     return IoCallDriver(pdx->NextStackDevice, Irp); // 调用下层驱动。
  294. }
  296. #pragma PAGEDCODE 
  297. // IRQL优先级高的使用分页内存，反之使用非分页内存。（维持系统稳定性）
  298. // 代码放在代码段，数据放在数据段。
  299. NTSTATUS HandleRemoveDevice(
  300.                             PDEVICE_EXTENSION pdx, // 扩展对象。
  301.                             PIRP Irp // IRP包对象。
  302.                            )
  303. {
  304.     PAGED_CODE(); // 它会检查当前函数是否运行低于DISPATCH_LEVEL的中断请求级，如果等于或高于这个中断请求级，将产生一个断言。它只在check版本中生效。
  305.     KdPrint(("Enter HandleRemoveDevice\n")); // 调试信息打印函数，它只在check版本中生效。
  307.     Irp->IoStatus.Status = STATUS_SUCCESS; // 本层IRP包处理完毕，设置标志。
  308.     NTSTATUS status = DefaultPnpHandler(pdx, Irp); // 将修改后的IRP包传递给下层驱动。
  310.     IoSetDeviceInterfaceState(&pdx->interfaceName, FALSE); // 使设备名失效。
  311.     RtlFreeUnicodeString(&pdx->interfaceName); // 释放UnicodeString。
  312.     // 调用IoDetachDevice()把fdo从设备栈中脱开。
  313.     if (pdx->NextStackDevice)
  314.         IoDetachDevice(pdx->NextStackDevice);
  315.     IoDeleteDevice(pdx->fdo); // 删除FDO。
  316.     IoDisconnectInterrupt(pdx->InterruptObject); // 删除中断。
  318.     KdPrint(("Leave HandleRemoveDevice\n")); // 调试信息打印函数，它只在check版本中生效。
  319.     return status;
  320. }    
  322. #pragma PAGEDCODE
  323. // IRQL优先级高的使用分页内存，反之使用非分页内存。（维持系统稳定性）
  324. // 代码放在代码段，数据放在数据段。
  325. NTSTATUS IO_CardPnp(
  326.                      IN PDEVICE_OBJECT fdo, // 本层FDO设备对象。
  327.                      IN PIRP Irp // 传进来的IRP对象。
  328.                      )
  329. {
  330.     PAGED_CODE(); // 它会检查当前函数是否运行低于DISPATCH_LEVEL的中断请求级，如果等于或高于这个中断请求级，将产生一个断言。它只在check版本中生效。
  331.     KdPrint(("Enter IO_CardPnp\n")); // 调试信息打印函数，它只在check版本中生效。
  333.     NTSTATUS status = STATUS_SUCCESS;
  334.     PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension; // 获取设备扩展对象的指针。
  335.     PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(Irp); // 获取驱动IO堆栈指针。
  336.     static NTSTATUS (*fcntab[])(PDEVICE_EXTENSION pdx, PIRP Irp) = // 声明函数指针数组。
  337.     {
  338.         HandleStartDevice,        // IRP_MN_START_DEVICE
  339.         DefaultPnpHandler,        // IRP_MN_QUERY_REMOVE_DEVICE
  340.         HandleRemoveDevice,        // IRP_MN_REMOVE_DEVICE
  341.         DefaultPnpHandler,        // IRP_MN_CANCEL_REMOVE_DEVICE
  342.         DefaultPnpHandler,        // IRP_MN_STOP_DEVICE
  343.         DefaultPnpHandler,        // IRP_MN_QUERY_STOP_DEVICE
  344.         DefaultPnpHandler,        // IRP_MN_CANCEL_STOP_DEVICE
  345.         DefaultPnpHandler,        // IRP_MN_QUERY_DEVICE_RELATIONS
  346.         DefaultPnpHandler,        // IRP_MN_QUERY_INTERFACE
  347.         DefaultPnpHandler,        // IRP_MN_QUERY_CAPABILITIES
  348.         DefaultPnpHandler,        // IRP_MN_QUERY_RESOURCES
  349.         DefaultPnpHandler,        // IRP_MN_QUERY_RESOURCE_REQUIREMENTS
  350.         DefaultPnpHandler,        // IRP_MN_QUERY_DEVICE_TEXT
  351.         DefaultPnpHandler,        // IRP_MN_FILTER_RESOURCE_REQUIREMENTS
  352.         DefaultPnpHandler,        // 
  353.         DefaultPnpHandler,        // IRP_MN_READ_CONFIG
  354.         DefaultPnpHandler,        // IRP_MN_WRITE_CONFIG
  355.         DefaultPnpHandler,        // IRP_MN_EJECT
  356.         DefaultPnpHandler,        // IRP_MN_SET_LOCK
  357.         DefaultPnpHandler,        // IRP_MN_QUERY_ID
  358.         DefaultPnpHandler,        // IRP_MN_QUERY_PNP_DEVICE_STATE
  359.         DefaultPnpHandler,        // IRP_MN_QUERY_BUS_INFORMATION
  360.         DefaultPnpHandler,        // IRP_MN_DEVICE_USAGE_NOTIFICATION
  361.         DefaultPnpHandler,        // IRP_MN_SURPRISE_REMOVAL
  362.     };
  364.     ULONG fcn = stack->MinorFunction; // 获取IRP的子类型。
  365.     if(fcn >= arraysize(fcntab)) // 未知的子类型。
  366.     {                        
  367.         status = DefaultPnpHandler(pdx, Irp); // 进行默认操作。
  369.         return status;
  370.     }                        
  372. #if DBG // 仅用于调试。
  373.     static char* fcnname[] = 
  374.     {
  375.         "IRP_MN_START_DEVICE",
  376.         "IRP_MN_QUERY_REMOVE_DEVICE",
  377.         "IRP_MN_REMOVE_DEVICE",
  378.         "IRP_MN_CANCEL_REMOVE_DEVICE",
  379.         "IRP_MN_STOP_DEVICE",
  380.         "IRP_MN_QUERY_STOP_DEVICE",
  381.         "IRP_MN_CANCEL_STOP_DEVICE",
  382.         "IRP_MN_QUERY_DEVICE_RELATIONS",
  383.         "IRP_MN_QUERY_INTERFACE",
  384.         "IRP_MN_QUERY_CAPABILITIES",
  385.         "IRP_MN_QUERY_RESOURCES",
  386.         "IRP_MN_QUERY_RESOURCE_REQUIREMENTS",
  387.         "IRP_MN_QUERY_DEVICE_TEXT",
  388.         "IRP_MN_FILTER_RESOURCE_REQUIREMENTS",
  389.         "",
  390.         "IRP_MN_READ_CONFIG",
  391.         "IRP_MN_WRITE_CONFIG",
  392.         "IRP_MN_EJECT",
  393.         "IRP_MN_SET_LOCK",
  394.         "IRP_MN_QUERY_ID",
  395.         "IRP_MN_QUERY_PNP_DEVICE_STATE",
  396.         "IRP_MN_QUERY_BUS_INFORMATION",
  397.         "IRP_MN_DEVICE_USAGE_NOTIFICATION",
  398.         "IRP_MN_SURPRISE_REMOVAL",
  399.     };
  401.     KdPrint(("PNP Request (%s)\n", fcnname[fcn]));
  402. #endif
  404.     status = (*fcntab[fcn])(pdx, Irp); // 响应IRP请求。
  406.     KdPrint(("Leave IO_CardPnp\n"));
  407.     return status;
  408. }
  410. #pragma PAGEDCODE
  411. // IRQL优先级高的使用分页内存，反之使用非分页内存。（维持系统稳定性）
  412. // 代码放在代码段，数据放在数据段。
  413. NTSTATUS IO_CardDispatchRoutine(IN PDEVICE_OBJECT fdo, IN PIRP Irp)
  414. {
  415.     PAGED_CODE();
  416.     KdPrint(("Enter IO_CardDispatchRoutine\n"));
  418.     Irp->IoStatus.Status = STATUS_SUCCESS; // 设置IRP对象状态。
  419.     Irp->IoStatus.Information = 0; // 设置实际传递比特数 。
  420.     IoCompleteRequest( Irp, IO_NO_INCREMENT ); // 完成请求。
  422.     KdPrint(("Leave IO_CardDispatchRoutine\n"));
  423.     return STATUS_SUCCESS;
  424. }
  426. // 完成IRP例程。
  427. NTSTATUS CompleteRequest(IN PIRP Irp, IN NTSTATUS status, IN ULONG_PTR info)
  428. {                        
  429.     Irp->IoStatus.Status = status;
  430.     Irp->IoStatus.Information = info;
  431.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  433.     return status;
  434. }
  436. // IO处理例程。
  437. // 每个IRP创建时，随之生成一个IO堆栈，IO堆栈与设备堆栈对应。
  438. NTSTATUS DispatchControl(PDEVICE_OBJECT fdo, PIRP Irp)
  439. {                            
  440.     PAGED_CODE();
  441.     NTSTATUS status;
  443.     ULONG info = 0;    
  444.     PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)fdo->DeviceExtension; // 获取设备扩展对象。
  445.     PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(Irp); // 获取设备IO堆栈。
  446.     ULONG cbin = stack->Parameters.DeviceIoControl.InputBufferLength; // 获取需要输入字符长度。
  447.     ULONG cbout = stack->Parameters.DeviceIoControl.OutputBufferLength; // 获取需要输出字符长度。
  448.     ULONG code = stack->Parameters.DeviceIoControl.IoControlCode; // 获取操作码。
  450.     // 判断使用何种操作。
  451.     switch(code)
  452.     {                        
  453.         case IOCTL_READ_BASE_BAR0:
  454.         {
  455.             ULONG offset = *(ULONG*)(Irp->AssociatedIrp.SystemBuffer);
  456.             PUCHAR buff = (PUCHAR)ExAllocatePool(NonPagedPool,cbout);
  457.             READ_REGISTER_BUFFER_UCHAR((PUCHAR)pdx->MemBar0+offset,buff,cbout);
  458.             RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, buff, cbout);
  459.             ExFreePool(buff);
  460.             info = cbout;
  461.             break;
  462.         }
  463.         case IOCTL_WRITE_BASE_BAR0:
  464.         {
  465.             int* tempPointer = (int*)Irp->AssociatedIrp.SystemBuffer;
  466.             ULONG offset = *(ULONG*)(tempPointer);
  467.             tempPointer++;
  468.             PUCHAR buff = *(PUCHAR*)(tempPointer);
  469.             tempPointer++;
  470.             ULONG nInputNumber = *(ULONG*)(tempPointer);
  471.             WRITE_REGISTER_BUFFER_UCHAR((PUCHAR)pdx->MemBar0+offset,buff,nInputNumber);
  472.             break;
  473.         }
  474.         case IOCTL_ENABLE_INT:
  475.         {
  476.             UCHAR HSR = READ_PORT_UCHAR(pdx->portbase);
  477.             HSR = HSR & 0xFB;
  478.             WRITE_PORT_UCHAR(pdx->portbase,HSR);
  479.             break;
  480.         }
  481.         case IOCTL_DISABLE_INT:
  482.         {
  483.             UCHAR HSR  = READ_PORT_UCHAR(pdx->portbase);
  484.             HSR = HSR | 0x04;
  485.             WRITE_PORT_UCHAR(pdx->portbase,HSR);
  486.             break;
  487.         }
  488.         default:
  489.         {
  490.             status = STATUS_INVALID_DEVICE_REQUEST;
  491.             break;
  492.         }
  493.     }
  495.     return CompleteRequest(Irp, status, info); // 调用完成IRP例程。
  496. }
  498. #pragma PAGEDCODE
  499. // 实际卸载处理在PNP IRP中完成
  500. void IO_CardUnload(IN PDRIVER_OBJECT DriverObject)
  501. {
  502.     PAGED_CODE();
  503.     KdPrint(("Enter IO_CardUnload\n"));
  504.     KdPrint(("Leave IO_CardUnload\n"));
  505. }
  507. </pre><pre name="code" class="cpp">
  509. </pre><pre name="code" class="cpp">
  511. </pre><pre name="code" class="cpp">
  513. </pre><pre name="code" class="cpp">
  515. </pre><pre name="code" class="cpp"><pre name="code" class="cpp">/************************************************************************
  516. * 文件名称:IO_Card.h                                                 
  517. * 作    者:丁观亮
  518. * 完成日期:2014-1-23
  519. *************************************************************************/
  521. #ifdef __cplusplus
  522. extern "C"
  523. {
  524. #endif
  526. #include <wdm.h>
  528. #ifdef __cplusplus
  529. }
  530. #endif 
  532. #define PAGEDCODE code_seg("PAGE")
  533. #define LOCKEDCODE code_seg()
  534. #define INITCODE code_seg("INIT")
  536. #define PAGEDDATA data_seg("PAGE")
  537. #define LOCKEDDATA data_seg()
  538. #define INITDATA data_seg("INIT")
  540. #define arraysize(p) (sizeof(p)/sizeof((p)[0])) // 数组大小计算宏
  542. // 扩展结构体，用来存储本层设备需要的信息
  543. typedef struct _DEVICE_EXTENSION
  544. {
  545.     PDEVICE_OBJECT fdo; // 上层设备
  546.     PDEVICE_OBJECT NextStackDevice; // 下层设备
  547.     UNICODE_STRING interfaceName; // 设备名（符号链接）
  549.     PKINTERRUPT InterruptObject; // 中断对象名
  550.     PUCHAR portbase; // IO端口地址
  551.     ULONG nports; // IO端口地址的数量
  552.     PVOID MemBar0; // 内存基地址0
  553.     ULONG nMem0; // 基地址BAR0占用字节数
  554.     BOOLEAN mappedport; // 如果为真需要做IO端口映射
  555. } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
  557. // 函数声明，在此声明可被外部引用
  558. extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,IN PUNICODE_STRING RegistryPath);
  559. NTSTATUS IO_CardAddDevice(IN PDRIVER_OBJECT DriverObject,IN PDEVICE_OBJECT PhysicalDeviceObject);
  560. NTSTATUS IO_CardPnp(IN PDEVICE_OBJECT fdo,IN PIRP Irp);
  561. NTSTATUS IO_CardDispatchRoutine(IN PDEVICE_OBJECT fdo,IN PIRP Irp);
  562. NTSTATUS DispatchControl(PDEVICE_OBJECT fdo, PIRP Irp);
  563. void IO_CardUnload(IN PDRIVER_OBJECT DriverObject);

Ioctls.h

  1. #ifndef IOCTLS_H
  2. #define IOCTLS_H
  4. #ifndef CTL_CODE
  5.     #pragma message("CTL_CODE undefined. Include winioctl.h or wdm.h")
  6. #endif
  8. // 读取BAR0基地址
  9. #define IOCTL_READ_BASE_BAR0 CTL_CODE( \
  10.             FILE_DEVICE_UNKNOWN, \
  11.             0x800, \
  12.             METHOD_BUFFERED, \
  13.             FILE_ANY_ACCESS)
  15. // 读取BAR0基地址
  16. #define IOCTL_WRITE_BASE_BAR0 CTL_CODE( \
  17.             FILE_DEVICE_UNKNOWN, \
  18.             0x801, \
  19.             METHOD_BUFFERED, \
  20.             FILE_ANY_ACCESS)
  22. // 开中断
  23. #define IOCTL_ENABLE_INT CTL_CODE( \
  24.             FILE_DEVICE_UNKNOWN, \
  25.             0x802, \
  26.             METHOD_BUFFERED, \
  27.             FILE_ANY_ACCESS)
  29. // 关中断
  30. #define IOCTL_DISABLE_INT CTL_CODE( \
  31.             FILE_DEVICE_UNKNOWN, \
  32.             0x803, \
  33.             METHOD_BUFFERED, \
  34.             FILE_ANY_ACCESS)
  36. #endif

Guid.h 

  1. // 定义设备的全局标识符（可用算法随机生成）
  2. DEFINE_GUID(IO_CARD_DEVICE, 0xe57c50f, 0xccc, 0x4ad2, 0xa8, 0x95, 0x93, 0xc5, 0xed, 0x11, 0x98, 0x60);
  4. <span style="font-family:Microsoft YaHei;font-size:24px;"><strong>IO_Card.inf</strong></span>
  6. <span style="font-family:Microsoft YaHei;font-size:24px;"><strong>
  7. </strong></span>
  9. <span style="font-family:Microsoft YaHei;font-size:24px;"><strong></strong></span><pre name="code" class="cpp">;-------------------------------------------------------------------------------------------
  12. ;版本节，INF文件的开始。
  13. [Version]
  15. ;inf文件实用的系统，指明驱动程序的签名，其取值为：$Windows NT$、$Windows 95$、$Chicago$。
  16. Signature="$CHICAGO$"
  18. ;inf文件的提供商。
  19. Provider=CPC_TECH
  21. ;指明驱动程序的版本信息，其格式为：mm/dd/yyyy,x.y.v.z。
  22. DriverVer=23/1/2014,1.0.0.1
  24. ;指明驱动程序所属的类别。
  25. Class=CPC_TECH_DEV
  27. ;指明设备类的GUID，其格式为：{nnnnnnnn-nnnn-nnnn-nnnnnnnnnnnn}。
  28. ClassGUID={EF2962F0-0D55-4bff-B8AA-2221EE8A79B0}
  30. ;指明数字签名文件的文件名，其扩展名为.cat。
  31. ;CatalogFile=
  33. ;仅由操作系统内部提供的INF文件使用。
  34. ;LayoutFile=
  37. ;-------------------------------------------------------------------------------------------
  40. ;指明设备驱动程序所在的磁盘或CD-ROM。
  41. [SourceDisksNames]
  43. ;格式为diskid=disk-description,tagfile,unused,path。
  44. ;disked：指出磁盘驱动器的编号
  45. ;disk-description：表示磁盘的描述信息，他通常为一个字符串。
  46. ;tagfile：指出磁盘标签文件的文件名。
  47. ;unused：为保留字段。
  48. ;path：指出驱动程序所在的路径。
  49. 1 = "IO_Card",Disk1,,
  52. ;指明设备驱动程序的文件名。
  53. [SourceDisksFiles]
  55. ;格式为filename=diskid,subdir,size。
  56. ;filename：指出驱动程序的文件名。
  57. ;diskid：指出磁盘驱动器的编号。
  58. ;subdir：指出该文件在磁盘上的路径。
  59. ;size：指出该文件未经压缩时的大小，以字节为单位。
  60. IO_Card.sys = 1,,
  62. ;目的路径
  63. [DestinationDirs]
  65. ;格式为File-list-section=dirid,subdir。
  66. ;file-list-section：指出CopyFiles、DelFiles、RenFiles指令所引用的节。
  67. ;dirid：指出目标目录值。
  68. ;subdir：指出dirid目录下的子目录。
  69. YouMark_Files_Driver = 10,System32\Drivers
  72. ;-------------------------------------------------------------------------------------------
  75. ;安装NT类到注册表中
  76. [ClassInstall32]
  77. Addreg=Class_AddReg
  79. [Class_AddReg]
  80. HKR,,,,%DeviceClassName%
  81. HKR,,Icon,,"-5"
  84. ;-------------------------------------------------------------------------------------------
  87. ;指明供应商及其对应Models接的名称。
  88. [Manufacturer]
  90. ;格式为%strkey%=models-section-name。
  91. ;strkey：代表设备制造的名字，其字符串值在String节中定义。
  92. ;models-section-name：指出Models节的名称。
  93. %MfgName%=Mfg0
  95. ;指明Install/DDInstall节的名称、设备的硬件ID和兼容ID等信息，其节名称由Manufacturer节指定。
  96. [Mfg0]
  98. ;格式为device-description=install-section-name,hw-id,compatiable-id…
  99. ;device-description：指出设备的表述信息，他可以是一个字符串，也可以是一个%strkey%。
  100. ;install-section-name：指出Install/DDInstall节的名称。
  101. ;hw-id：指出设备的硬件ID。
  102. ;compatiable-id：指出设备的兼容ID。
  103. %DeviceDesc%=YouMark_DDI, PCI\VEN_10b5&DEV_9054
  106. ;-------------------------------------------------------------------------------------------
  109. ;指明需复制的文件、想注册表中添加的内容等信息，其节名称由Models节指定。
  110. [YouMark_DDI.NT]
  112. ;格式为CopyFiles=@filename|file-list-section
  113. ;filename：指出目标文件名。
  114. ;file-list-section：是其创建的文件列表节。
  115. CopyFiles=YouMark_Files_Driver
  116. ;格式为AddReg=add-registry-section
  117. ;add-registry-section：创建的添加注册表节。
  118. AddReg=YouMark_NT_AddReg
  120. ;文件列表节。
  121. [YouMark_Files_Driver]
  122. IO_Card.sys
  124. ;注册表节。
  125. [YouMark_NT_AddReg]
  126. ;格式为reg-root, [subkey], [value-entry-name], [flags], [value]。
  127. ;reg-root：指出注册表树的根目录。
  128. ;subkey：指出reg-root下的子目录。
  129. ;value-entry-name：指出要增加的注册表值。
  130. ;flags：指出其对注册表的一些处理方。
  131. ;value：指出新增加注册表值的数据。
  132. HKLM, "System\CurrentControlSet\Services\IO_Card\Parameters",\
  133. "BreakOnEntry", 0x00010001, 0
  135. ;用于控制设备驱动程序的安装过程。
  136. [YouMark_DDI.NT.Services]
  138. ;格式为AddService=ServiceName,[flags],service-install-section[,event-log-install-section[,[EventLogType][,EventName]]]…。
  139. ;ServiceName：指出驱动程序的名字。
  140. ;flags：指出一个或多个系统定义的标识。
  141. ;service-install-section：是其创建的服务安装节。
  142. ;event-log-install-section：是其创建的事件日志安装。
  143. ;EventLogType：指出事件日志的类型。
  144. ;EventName：指出事件日志的名字。
  145. Addservice = IO_Card, 0x00000002, YouMark_AddService
  147. ;创建的服务安装节。
  148. [YouMark_AddService]
  150. ;服务显示名称要和设备名称相同。
  151. DisplayName = %SvcDesc%
  153. ;指明驱动程序的类型。
  154. ServiceType = 1 ; SERVICE_KERNEL_DRIVER
  156. ;指明驱动程序的启动类型。
  157. StartType = 3 ; SERVICE_DEMAND_START
  159. ;指明驱动程序的差错控制级别。
  160. ErrorControl = 1 ; SERVICE_ERROR_NORMAL
  162. ;指明驱动程序的路径。
  163. ServiceBinary = %10%\System32\Drivers\IO_Card.sys
  166. ;-------------------------------------------------------------------------------------------
  169. ;指明一些列字符串，当某些字符串频繁地出现在INF文件中，为简化输入，可以在该节中定义一个字符串变量，代表该字符串出现在INF文件中。
  170. [Strings]
  171. ProviderName="Ding Guanliang."
  172. MfgName="CPC_TECH"
  173. DeviceDesc="IO_Card"
  174. DeviceClassName="CPC_TECH_Device"
  175. SvcDesc="Ding Guanliang"

发表评论

表情：
评论列表 （有 0 条评论，328人围观）

还没有评论，来说两句吧...

相关阅读

    相关 chrome驱动(chrome驱动最新版本)

    chrome浏览器怎么样？ 设置，只有5项，数量上属于短期记忆的能力范围内，减少了用户的认知负担，此时用户关注点只在浏览本身上，几乎不需要对浏览器进行额外的学习 ![c

    红太狼红太狼/ 0 赞/ 255 阅读

    相关 驱动科普

    驱动干的事情，简单可以说成是：初始化和配置硬件；实现硬件的数据的接受和发送   转载于:https://www.cnblogs.com/yangxingsha/

    灰太狼灰太狼/ 0 赞/ 137 阅读

    相关 数据驱动

    Vue.js    ⼀个核⼼思想是数据驱动。所谓数据驱动，是指视图是由数据驱动⽣成的，我们对视图的修改， 不会直接操作    DOM，⽽是通过修改数据。它相⽐我们传统的前端开发

    小咪咪小咪咪/ 0 赞/ 382 阅读