驱动分层-挂载设备对象示例

最新推荐文章于 2023-08-24 13:44:04 发布
最新推荐文章于 2023-08-24 13:44:04 发布
阅读量580 收藏
点赞数
分类专栏： windows驱动编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsgxiaomianao/article/details/34798503
版权

（一）框架

（1）标准驱动A（被挂载的驱动）：IRP_MJ_READ派遣函数演示，添加timer例程，用来延时异步的调用过程

（2）挂载驱动B（将此驱动挂载到标准驱动A上面）：获得标准驱动A的设备对象指针，在IRP_MJ_READ派遣函数内不做任何处理，仅仅将IRP传递给标准驱动

（3）exe程序，打开标准驱动A设备，并使用ReadFile出发一个IRP_MJ_READ的IRP


（二）结果：应用程序调用标准驱动A，但首先是挂载的驱动B收到IRP_MJ_READ的IRP，然后驱动B将IRP传递给标准驱动A


标准驱动A代码：

///
///
/// Copyright (c) 2014 - <company name here>
///
/// Original filename: StandardDriver.cpp
/// Project          : StandardDriver
/// Date of creation : 2014-06-24
/// Author(s)        : <author name(s)>
///
/// Purpose          : <description>
///
/// Revisions:
///  0000 [2014-06-24] Initial revision.
///
///

// $Id$

#ifdef __cplusplus
extern "C" {
#endif
#include <ntddk.h>
#include <string.h>
#ifdef __cplusplus
}; // extern "C"
#endif

#include "StandardDriver.h"

#ifdef __cplusplus
namespace { // anonymous namespace to limit the scope of this global variable!
#endif
PDRIVER_OBJECT pdoGlobalDrvObj = 0;
#ifdef __cplusplus
}; // anonymous namespace
#endif





typedef struct _DEVICE_EXTENSION 
{
	UNICODE_STRING usDevName;
	UNICODE_STRING usLinkName;
	PDEVICE_OBJECT pDevObj;

	KDPC pollingDPC;//存储DPC对象
	KTIMER pollingTimer;//存储计时器对象
	PIRP pendingIrp;//记录当前挂起的IRP

}DEVICE_EXTENSION,*PDEVICE_EXTENSION;



VOID TimerDpc(
			  __in struct _KDPC  *Dpc,
			  __in_opt PVOID  DeferredContext,
			  __in_opt PVOID  SystemArgument1,
			  __in_opt PVOID  SystemArgument2
			  )
{

	PDEVICE_OBJECT pDevObj = (PDEVICE_OBJECT)DeferredContext;
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;

	PIRP currentPendingIrp = pDevExt->pendingIrp;

	NTSTATUS status = STATUS_SUCCESS;

	currentPendingIrp->IoStatus.Status = status;
	currentPendingIrp->IoStatus.Information = 0;
	IoCompleteRequest(currentPendingIrp,IO_NO_INCREMENT);

	KdPrint(("StandardDriver-TimerDpc.."));


}



NTSTATUS STANDARDDRIVER_DispatchCreateClose(
    IN PDEVICE_OBJECT		DeviceObject,
    IN PIRP					Irp
    )
{
    NTSTATUS status = STATUS_SUCCESS;
    Irp->IoStatus.Status = status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

NTSTATUS STANDARDDRIVER_DispatchDeviceControl(
    IN PDEVICE_OBJECT		DeviceObject,
    IN PIRP					Irp
    )
{
    NTSTATUS status = STATUS_SUCCESS;
    PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);

    switch(irpSp->Parameters.DeviceIoControl.IoControlCode)
    {
    case IOCTL_STANDARDDRIVER_OPERATION:
        // status = SomeHandlerFunction(irpSp);
        break;
    default:
        Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
        Irp->IoStatus.Information = 0;
        break;
    }

    status = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

VOID STANDARDDRIVER_DriverUnload(
    IN PDRIVER_OBJECT		DriverObject
    )
{
    PDEVICE_OBJECT pdoNextDeviceObj = pdoGlobalDrvObj->DeviceObject;
    IoDeleteSymbolicLink(&usSymlinkName);

    // Delete all the device objects
    while(pdoNextDeviceObj)
    {
        PDEVICE_OBJECT pdoThisDeviceObj = pdoNextDeviceObj;
        pdoNextDeviceObj = pdoThisDeviceObj->NextDevice;
        IoDeleteDevice(pdoThisDeviceObj);
    }

	KdPrint(("StandardDriver-DriverUnload.."));

}

NTSTATUS StandardDriver_ReadDispath(PDEVICE_OBJECT pDevObj,PIRP pIrp)
{
	NTSTATUS status = STATUS_SUCCESS;

	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;

	IoMarkIrpPending(pIrp);

	pDevExt->pendingIrp = pIrp;

	ULONG uMicroSec = 3000000;
	LARGE_INTEGER lTime = RtlConvertLongToLargeInteger(-10*uMicroSec);

	KeSetTimer(&(pDevExt->pollingTimer),lTime,&(pDevExt->pollingDPC));

	status = STATUS_PENDING;

	KdPrint(("StandardDriver-ReadDispath.."));


	return status;
}




#ifdef __cplusplus
extern "C" {
#endif
NTSTATUS DriverEntry(
    IN OUT PDRIVER_OBJECT   DriverObject,
    IN PUNICODE_STRING      RegistryPath
    )
{
    PDEVICE_OBJECT pdoDeviceObj = 0;
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    pdoGlobalDrvObj = DriverObject;

	KdPrint(("StandardDriver-DriverEntry.."));


    // Create the device object.
    if(!NT_SUCCESS(status = IoCreateDevice(
        DriverObject,
        sizeof(DEVICE_EXTENSION),//0,
        &usDeviceName,
        FILE_DEVICE_UNKNOWN,
        FILE_DEVICE_SECURE_OPEN,
        FALSE,
        &pdoDeviceObj
        )))
    {
        // Bail out (implicitly forces the driver to unload).
        return status;
    };



	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pdoDeviceObj->DeviceExtension;
	pDevExt->usDevName = usDeviceName;
	pDevExt->usLinkName = usSymlinkName;
	pDevExt->pDevObj = pdoDeviceObj;


	KeInitializeDpc(&(pDevExt->pollingDPC),TimerDpc,(PVOID)pdoDeviceObj);
	KeInitializeTimer(&(pDevExt->pollingTimer));


	pdoDeviceObj->Flags |= DO_BUFFERED_IO;

    // Now create the respective symbolic link object
    if(!NT_SUCCESS(status = IoCreateSymbolicLink(
        &usSymlinkName,
        &usDeviceName
        )))
    {
        IoDeleteDevice(pdoDeviceObj);
        return status;
    }

    // NOTE: You need not provide your own implementation for any major function that
    //       you do not want to handle. I have seen code using DDKWizard that left the
    //       *empty* dispatch routines intact. This is not necessary at all!
    DriverObject->MajorFunction[IRP_MJ_CREATE] =
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = STANDARDDRIVER_DispatchCreateClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = STANDARDDRIVER_DispatchDeviceControl;
	DriverObject->MajorFunction[IRP_MJ_READ] = StandardDriver_ReadDispath;
    DriverObject->DriverUnload = STANDARDDRIVER_DriverUnload;

    return STATUS_SUCCESS;
}
#ifdef __cplusplus
}; // extern "C"
#endif

挂载驱动B的代码： 

///
///
/// Copyright (c) 2014 - <company name here>
///
/// Original filename: AttDevStandardDev.cpp
/// Project          : AttDevStandardDev
/// Date of creation : 2014-06-25
/// Author(s)        : <author name(s)>
///
/// Purpose          : <description>
///
/// Revisions:
///  0000 [2014-06-25] Initial revision.
///
///

// $Id$

#ifdef __cplusplus
extern "C" {
#endif
#include <ntddk.h>
#include <string.h>
#ifdef __cplusplus
}; // extern "C"
#endif

#include "AttDevStandardDev.h"

#ifdef __cplusplus
namespace { // anonymous namespace to limit the scope of this global variable!
#endif
PDRIVER_OBJECT pdoGlobalDrvObj = 0;
#ifdef __cplusplus
}; // anonymous namespace
#endif



typedef struct _DEVICE_EXTENSION 
{

	UNICODE_STRING usDevName;
	UNICODE_STRING usLinkName;
	PDEVICE_OBJECT pDevObj;


	//PDEVICE_OBJECT pNextDevObj;
	PDEVICE_OBJECT pTargetDevobj;

}DEVICE_EXTENSION,*PDEVICE_EXTENSION;


NTSTATUS ATTDEVSTANDARDDEV_DispatchCreateClose(
    IN PDEVICE_OBJECT		DeviceObject,
    IN PIRP					Irp
    )
{
    NTSTATUS status = STATUS_SUCCESS;
    Irp->IoStatus.Status = status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

NTSTATUS ATTDEVSTANDARDDEV_DispatchDeviceControl(
    IN PDEVICE_OBJECT		DeviceObject,
    IN PIRP					Irp
    )
{
    NTSTATUS status = STATUS_SUCCESS;
    PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);

    switch(irpSp->Parameters.DeviceIoControl.IoControlCode)
    {
    case IOCTL_ATTDEVSTANDARDDEV_OPERATION:
        // status = SomeHandlerFunction(irpSp);
        break;
    default:
        Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
        Irp->IoStatus.Information = 0;
        break;
    }

    status = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

VOID ATTDEVSTANDARDDEV_DriverUnload(
    IN PDRIVER_OBJECT		DriverObject
    )
{

	KdPrint(("ATTDEVSTANDARDDEV_DriverUnload .."));


    PDEVICE_OBJECT pdoNextDeviceObj = pdoGlobalDrvObj->DeviceObject;
    //IoDeleteSymbolicLink(&usSymlinkName);

    // Delete all the device objects
    while(pdoNextDeviceObj)
    {
		PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pdoNextDeviceObj->DeviceExtension;

		pdoNextDeviceObj =pdoNextDeviceObj->NextDevice;

		//从设备栈弹出
		IoDetachDevice(pDevExt->pTargetDevobj);

		//删除该设备对象
		IoDeleteDevice(pDevExt->pDevObj);

        //PDEVICE_OBJECT pdoThisDeviceObj = pdoNextDeviceObj;
       // pdoNextDeviceObj = pdoThisDeviceObj->NextDevice;
        //IoDeleteDevice(pdoThisDeviceObj);
    }

	KdPrint(("ATTDEVSTANDARDDEV_DriverUnload leave"));
}


NTSTATUS ReadDiaptch(PDEVICE_OBJECT pDevObj,PIRP pIrp)
{
	NTSTATUS status = STATUS_SUCCESS;

	KdPrint(("Attach Device ReadDiaptch...."));
	//转发给下一层驱动
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;

	//略过当前堆栈
	IoSkipCurrentIrpStackLocation(pIrp);

	//调用下一层驱动
	status = IoCallDriver(pDevExt->pTargetDevobj,pIrp);


	KdPrint(("Attach Device ReadDiaptch....leave..."));

	return status;
}


#ifdef __cplusplus
extern "C" {
#endif
NTSTATUS DriverEntry(
    IN OUT PDRIVER_OBJECT   DriverObject,
    IN PUNICODE_STRING      RegistryPath
    )
{

	KdPrint(("Attach Device DriverEntry....."));


    PDEVICE_OBJECT pdoDeviceObj = 0;
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    pdoGlobalDrvObj = DriverObject;
	PDEVICE_EXTENSION pDevExt;



	//获得将要绑定的设备的对象指针和文件对象指针
	UNICODE_STRING usStandardDevName;
	RtlInitUnicodeString(&usStandardDevName,L"\\Device\\STANDARDDRIVER_DeviceName");
	PDEVICE_OBJECT pDeviceObj;
	PFILE_OBJECT pFileObject;
	status = IoGetDeviceObjectPointer(&usStandardDevName,FILE_ALL_ACCESS,&pFileObject,&pDeviceObj);
	if (!NT_SUCCESS(status))
	{
		KdPrint(("AttaceDev:IoGetDeviceObjectPointer Error:0x%x",status));
		return status;
	}

	//创建自己的设备
    if(!NT_SUCCESS(status = IoCreateDevice(
        DriverObject,
        sizeof(DEVICE_EXTENSION),//0,
        &usDeviceName,
        FILE_DEVICE_UNKNOWN,
        FILE_DEVICE_SECURE_OPEN,
        FALSE,
        &pdoDeviceObj
        )))
    {
		KdPrint(("AttaceDev:IoCreateDevice Error:0x%x",status));

        // Bail out (implicitly forces the driver to unload).
		ObDereferenceObject(pFileObject);//引用计数减一
        return status;
    };

	pdoDeviceObj->Flags |= DO_BUFFERED_IO;


	pDevExt = (PDEVICE_EXTENSION)pdoDeviceObj->DeviceExtension;
	pDevExt->usDevName = usDeviceName;
	pDevExt->usLinkName = usSymlinkName;
	pDevExt->pDevObj = pdoDeviceObj;

	// Now create the respective symbolic link object
	if(!NT_SUCCESS(status = IoCreateSymbolicLink(
		&usSymlinkName,
		&usDeviceName
		)))
	{
		KdPrint(("AttaceDev:IoCreateSymbolicLink Error:0x%x",status));

		IoDeleteDevice(pdoDeviceObj);
		return status;
	}
	DriverObject->MajorFunction[IRP_MJ_CREATE] =
		DriverObject->MajorFunction[IRP_MJ_CLOSE] = ATTDEVSTANDARDDEV_DispatchCreateClose;
	DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ATTDEVSTANDARDDEV_DispatchDeviceControl;
	DriverObject->MajorFunction[IRP_MJ_READ] = ReadDiaptch;
	DriverObject->DriverUnload = ATTDEVSTANDARDDEV_DriverUnload;



	//保存信息到设备扩展
	pDevExt = (PDEVICE_EXTENSION)DriverObject->DeviceObject->DeviceExtension;
	//设备扩展得到下层驱动设备
	PDEVICE_OBJECT pFilterDevObj = pDevExt->pDevObj;

	//自己的设备挂载到标准驱动的设备上
	PDEVICE_OBJECT pTargetDevObj = IoAttachDeviceToDeviceStack(pFilterDevObj,pDeviceObj);

	pDevExt->pTargetDevobj = pTargetDevObj;

	if (!pTargetDevObj)
	{
		KdPrint(("AttaceDev:IoAttachDeviceToDeviceStack Error:0x%x",status));

		ObDereferenceObject(pFileObject);
		IoDeleteDevice(pFilterDevObj);
		return STATUS_INSUFFICIENT_RESOURCES;
	}


	//设置设备类型
	pFilterDevObj->DeviceType = pTargetDevObj->DeviceType;
	//设置设备对象特征
	pFilterDevObj->Characteristics = pTargetDevObj->Characteristics;
	//设置设备对象标记
	pFilterDevObj->Flags &= ~ DO_DEVICE_INITIALIZING;
	pFilterDevObj->Flags |= (pTargetDevObj->Flags & (DO_DIRECT_IO | DO_BUFFERED_IO));

	ObDereferenceObject(pFileObject);

	KdPrint(("Attach Device DriverEntry..... leave"));

    return STATUS_SUCCESS;
}
#ifdef __cplusplus
}; // extern "C"
#endif

exe应用程序代码： 

// CallDriver.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "CallDriver.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// 唯一的应用程序对象

CWinApp theApp;

using namespace std;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
	int nRetCode = 0;

	// 初始化 MFC 并在失败时显示错误
	if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
	{
		// TODO: 更改错误代码以符合您的需要
		_tprintf(_T("错误: MFC 初始化失败\n"));
		nRetCode = 1;
	}
	else
	{
		// TODO: 在此处为应用程序的行为编写代码。
	}

	HANDLE hdl = CreateFile(L"\\\\.\\STANDARDDRIVER_DeviceName",
		GENERIC_WRITE | GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL ,NULL);
	if (hdl == INVALID_HANDLE_VALUE)
	{
		CString csLog;
		csLog.Format(L"CreateFile Error:%d",GetLastError());
		AfxMessageBox(csLog);
		return -1;
	}

	DWORD dwRetLen = 0;
	BOOL bRetRead = ReadFile(hdl,NULL,0,&dwRetLen,NULL);
	if (bRetRead)
	{
		cout<<"ReadFile OK!"<<endl;
	}
	CloseHandle(hdl);

	system("PAUSE");

	return nRetCode;
}



wsgxiaomianao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式Linux字符设备驱动-分层后的LED字符设备驱动-系统级驱动+芯片级驱动
03-02
基于最基本的Linux LED字符设备进行改进，在原来的基础上将驱动进行分层设计，拆分出通用的部分作为系统级驱动，剩余的跟芯片相关的部分作为芯片级驱动，以后系统级驱动和芯片级驱动可单独维护，互不影响。...
windows分层驱动程序的挂载
10-23
翻开历史大概 建发股份离开国际法离开国际法两国飞法国建立开放的价格法 官方价格放开了的感觉仿佛感觉
I2C设备驱动挂载
最新发布
Linux驱动开发工程师，熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配，Linux上层应用开发，主要集中在瑞芯微和全志平台。
08-24 398
I2C工作原理：I2C总线标准的两根传输线，SDA是数据线，Scl是时钟线，当SCL为高，SDA由高到低时，发送启动信息，发送9个脉冲，1-7是地址，8是读写控制位，9是ACK应答位，所以挂在I2C上的被控设备都接受所发送的信息，并把接收到的7位地址与自己的地址进行比较，如果相同ACK就会反馈应答。当SCL为低，SDA由低-à高，则发送停止信号。Linux的I2C构架分为三个部分：1）I2C core框架提供了核心数据结构的定义和相关接口函数，用来实现I2C适配器。
【Linux】【驱动】驱动框架以及挂载驱动
伪NChris的博客
08-12 677
将当前路径下的chrdevbase.ko 文件移动到/home/book/nfs_rootfs/路径。一个驱动可以编译成驱动模块然后挂载到驱动中去，也可以编译到系统中去，下面演示第一种方法。obj-m := chrdevbase.o ：表示你编译的文件的名称。KERNELDIR ：表示你Linux内核源码的位置。驱动文件名称 chrdevbase.c。如下图表示已经修改成功了。配置全局变量为ARM。
加载驱动方法
一念永恒
04-13 663
1.Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");2. DriverManager.registerDriver(new com.mysql.jdbc.Driver());3.System.setProperty("jdbc.drivers", "com.mysql.jdbc.Driver");
编译驱动代码及挂载步骤
hhltaishuai的博客
07-20 272
将写好的代码放到 drivers/char/目录下 cp pin4driver2.c /drivers/char/ . 修改Makefile文件 obj-m pin4driver2.o 编译.ko文件 ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- KERNEL=kernel7 make modules 生成ko文件复制到树莓派 scp drivers/char/pin4driver2.ko pi@192.168.1.72:/home/pi 交叉编译 a
[Win驱动9]Windows分层驱动
輚至消亡
10-31 370
ghfd
行业分类-设备装置-分层纤维防伪纸.zip
08-26
《行业分类-设备装置-分层纤维防伪纸》这一主题涉及到的是信息技术在防伪领域的应用，特别是关于分层纤维防伪纸的介绍。防伪技术是保护知识产权、防止假冒伪劣产品的重要手段，而设备装置则是实现这些技术的关键硬件...
行业分类-设备装置-分层地分解消息.zip
08-26
标题中的“行业分类-设备装置-分层地分解消息”暗示了这可能是一个关于工业自动化、设备管理和信息通信技术在设备层应用的主题。这个压缩包包含的“分层地分解消息.pdf”很可能是详细的报告或教程，讲解如何在不同的...
行业分类-设备装置-动态分层教学设备和动态分层教学方法.zip
08-24
动态分层教学设备和动态分层教学方法是教育技术领域中的一个重要概念，旨在提升课堂教学效率，适应不同学生的学习能力和进度。这种教学模式基于学生的能力差异，将他们分成不同的层次，提供个性化的教学资源和教学...
行业分类-设备装置-分层媒体比特流的打包.zip
08-26
这个压缩包文件"行业分类-设备装置-分层媒体比特流的打包.zip"显然包含了关于这一主题的专业资料，主要文件为"分层媒体比特流的打包.pdf"。 首先，我们要理解什么是分层媒体比特流。在数字媒体处理中，数据通常被...
行业分类-设备装置-处理分层媒体数据的方法和设备.zip
08-23
分层媒体数据通常指的是将一个多媒体对象（如图像或视频）分解成多个独立的层次，每个层次包含不同的信息，例如背景、前景、动画元素等。这样的分层结构便于对各个部分进行单独编辑，提高编辑效率，并且在处理复杂...
行业分类-设备装置-分层纸张的制造方法.zip
08-26
分层纸张制造则可能引入新的工艺步骤，如分层结构的形成和控制，这可能需要特殊设备和技术，以确保各层之间的紧密贴合和均匀分布。 3. **机械工程**：制造设备的设计和优化是关键。例如，可能需要开发新型的混合器...
行业分类-设备装置-分层复合芳纶纤维纸及其制备方法.zip
08-17
《行业分类-设备装置-分层复合芳纶纤维纸及其制备方法》是关于高科技材料领域的一个重要主题，尤其在设备装置行业中具有广泛的应用。本文将深入探讨分层复合芳纶纤维纸的特性、制备过程及其在不同领域的应用。 首先...
输入设备驱动之按键设备驱动
08-10
Linux 的输入子系统是一个基于分层模式的系统，主要包括三个部分：设备驱动层（input driver）、核心层（input core）和输入事件驱动层。输入子系统的划分使得输入设备的驱动程序设计越来越简单，但是其中的思想...
【Linux设备驱动】如何挂载和卸载驱动 lsmod insmod rmmod和modprobe
Tschome的博客
11-14 4295
如何挂载卸载以及查看linux设备驱动呢,主要包含insmod,rmmod,lsmod以及modprobe
Linux 驱动挂载顺序分析
u010783226的专栏
06-09 2424
linux
linux设备和驱动加载的先后顺序
热门推荐
maopig的专栏
03-20 2万+
Linux驱动先注册总线，总线上可以先挂device，也可以先挂driver，那么究竟怎么控制先后的顺序呢。 Linux系统使用两种方式去加载系统中的模块：动态和静态。 静态加载：将所有模块的程序编译到Linux内核中，由do_initcall函数加载 核心进程（/init/main.c）kernel_inità do_basic_setup()àdo_initcalls（）该函数中会将在_
Linux设备驱动开发入门与LED驱动示例
LED驱动是设备驱动开发中的基础示例，用于演示最基本的驱动编写流程。在无操作系统环境下，可能需要直接控制GPIO引脚来切换LED状态。而在Linux下，需要通过内核API注册驱动，处理设备文件操作，如open、close、read...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值