字符设备驱动的三种实现方法

已于 2022-05-10 20:37:38 修改
阅读量1.9k 收藏 25
点赞数 2
分类专栏： Linux驱动 设备树学习 文章标签： 驱动开发 设备树 Linux 嵌入式
于 2022-05-09 22:21:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45842280/article/details/124652291
版权

目录

一、驱动程序编写的三种方法

a. 驱动程序编写有3种方法：传统方法、使用总线设备驱动模型、使用设备树

b. 这3种方法也核心都是一样的: 分配、设置、注册 file_operations结构体
 这个结构体中有.open, .read, .write, .ioctl等成员
 驱动程序要实现这些成员，在这些成员函数中操作硬件

c. 这3种方法的差别在于：如何指定硬件资源，比如如何指定LED引脚是哪个

c.1传统方法: 在驱动程序代码中写死硬件资源, 代码简单/不易扩展

c.2 总线设备驱动模型: 把驱动程序分为两部分(platform_driver, platform_device)
 在platform_device中指定硬件资源,
 在platform_driver中分配/设置/注册 file_operations结构体, 并从platform_device获得硬件资源

特点：
易于扩展，但是有很多冗余代码(每种配置都对应一个platform_device结构体), 
硬件有变动时需要重新编译内核或驱动程序。

c.3 使用设备树指定硬件资源: 驱动程序也分为两部分(platform_driver, 设备树*.dts)在设备树*.dts中指定硬件资源, dts被编译为dtb文件, 在启动单板时会将dtb文件传给内核,内核根据dtb文件分配/设置/注册多个platform_device, platform_driver的编写方法跟"总线设备驱动模型"一样。

特点：
易于扩展，没有冗余代码
硬件有变动时不需要重新编译内核或驱动程序，只需要提供不一样的dtb文件

注: dts  - device tree source  // 设备树源文件
    dtb  - device tree blob    // 设备树二进制文件, 由dts编译得来
    blob - binary large object

二、字符设备驱动的传统写法

a. 分配file_operations结构体
b. 设置file_operations结构体
 该结构体中有.open,.read,.write等成员,
 在这些成员函数中去操作硬件
c. 注册file_operations结构体:
 register_chrdev(major, name, &fops)
d. 入口函数: 调用register_chrdev
e. 出口函数: 调用unregister_chrdev

//驱动示例代码如下
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>

#define S3C2440_GPA(n)  (0<<16 | n)//n表明使用该端口的那个引脚
#define S3C2440_GPB(n)  (1<<16 | n)
#define S3C2440_GPC(n)  (2<<16 | n)
#define S3C2440_GPD(n)  (3<<16 | n)
#define S3C2440_GPE(n)  (4<<16 | n)
#define S3C2440_GPF(n)  (5<<16 | n)
#define S3C2440_GPG(n)  (6<<16 | n)
#define S3C2440_GPH(n)  (7<<16 | n)
#define S3C2440_GPI(n)  (8<<16 | n)
#define S3C2440_GPJ(n)  (9<<16 | n)

static int led_pin = S3C2440_GPF(5);//使用GPIOF5引脚
static volatile unsigned int *gpio_con;//用于存储寄存器地址
static volatile unsigned int *gpio_dat;

/* 123. 分配/设置/注册file_operations 
 * 4. 入口
 * 5. 出口
 */

static int major;
static struct class *led_class;

static unsigned int gpio_base[] = {//该数组存储了各个类型寄存器的基地址
	0x56000000, /* GPACON */
	0x56000010, /* GPBCON */
	0x56000020, /* GPCCON */
	0x56000030, /* GPDCON */
	0x56000040, /* GPECON */
	0x56000050, /* GPFCON */
	0x56000060, /* GPGCON */
	0x56000070, /* GPHCON */
	0,          /* GPICON */
	0x560000D0, /* GPJCON */
};

static int led_open (struct inode *node, struct file *filp)
{
	/* 把LED引脚配置为输出引脚 */
	/* GPF5 - 0x56000050 */
	int bank = led_pin >> 16;//得到端口号，使用的是A端口还是F端口
	int base = gpio_base[bank];

	int pin = led_pin & 0xffff;//得到引脚号，使用某个端口的第几个引脚
	gpio_con = ioremap(base, 8);//进行地址映射，内核中使用的是虚拟地址，要将原本的物理地址进行映射
	if (gpio_con) {
		printk("ioremap(0x%x) = 0x%x\n", base, gpio_con);
	}
	else {
		return -EINVAL;
	}
	
	gpio_dat = gpio_con + 1;//这两个寄存器地址相邻，加一相差四个字节，32位系统

	*gpio_con &= ~(3<<(pin * 2));//将寄存器要设置的两个位清零
	*gpio_con |= (1<<(pin * 2)); //将上边清零的两个位进行赋值设置

	return 0;
}

static ssize_t led_write (struct file *filp, const char __user *buf, size_t size, loff_t *off)
{
	/* 根据APP传入的值来设置LED引脚 */
	unsigned char val;
	int pin = led_pin & 0xffff;
	
	copy_from_user(&val, buf, 1);//拷贝用户空间的内容，内核与应用层进行数据交换

	if (val)
	{
		/* 点灯 */
		*gpio_dat &= ~(1<<pin);
	}
	else
	{
		/* 灭灯 */
		*gpio_dat |= (1<<pin);
	}

	return 1; /* 已写入1个数据 */
}

static int led_release (struct inode *node, struct file *filp)
{
	printk("iounmap(0x%x)\n", gpio_con);
	iounmap(gpio_con);//释放映射
	return 0;
}


static struct file_operations myled_oprs = {
	.owner = THIS_MODULE,
	.open  = led_open,
	.write = led_write,
	.release = led_release,
};


static int myled_init(void)
{
	major = register_chrdev(0, "myled", &myled_oprs);

	led_class = class_create(THIS_MODULE, "myled");
	device_create(led_class, NULL, MKDEV(major, 0), NULL, "led"); /* /dev/led */

	return 0;
}

static void myled_exit(void)
{
	unregister_chrdev(major, "myled");
	device_destroy(led_class,  MKDEV(major, 0));
	class_destroy(led_class);
}

module_init(myled_init);
module_exit(myled_exit);

MODULE_LICENSE("GPL");

//应用层代码，用于测试LED驱动能否正常工作
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

/* ledtest on
  * ledtest off
  */
int main(int argc, char **argv)
{
	int fd;
	unsigned char val = 1;
	fd = open("/dev/led", O_RDWR);
	if (fd < 0)
	{
		printf("can't open!\n");
	}
	if (argc != 2)
	{
		printf("Usage :\n");
		printf("%s <on|off>\n", argv[0]);
		return 0;
	}

	if (strcmp(argv[1], "on") == 0)
	{
		val  = 1;
	}
	else
	{
		val = 0;
	}
	
	write(fd, &val, 1);
	return 0;
}

三、总线设备驱动模型

a. 驱动程序分为platform_device和platform_driver两部分
 platform_device : 指定硬件资源
 platform_driver : 根据与之匹配的platform_device获得硬件资源, 并分配/设置/注册file_operations

b. 如何确定platform_device和platform_driver是否匹配?
 b.1 platform_device含有name
 b.2 platform_driver.id_table"可能"指向一个数组, 每个数组项都有name, 表示该platform_driver所能支持的platform_device
 b.3 platform_driver.driver含有name, 表示该platform_driver所能支持的platform_device
 b.4 优先比较b.1, b.2两者的name, 若相同则表示互相匹配
 b.5 如果platform_driver.id_table为NULL, 则比较b.1, b.3两者的name, 若相同则表示互相匹配
在这里插入图片描述
  总线设备驱动模型只是一个编程技巧, 它把驱动程序分为"硬件相关的部分"、“变化不大的驱动程序本身”, 这个技巧并不是驱动程序的核心, 核心仍然是"分配/设置/注册file_operations"

//驱动程序示例代码：led_dev.c,即device部分
#include <linux/module.h>
#include <linux/version.h>

#include <linux/init.h>

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/serial_core.h>
#include <linux/platform_device.h>

#define S3C2440_GPA(n)  (0<<16 | n)
#define S3C2440_GPB(n)  (1<<16 | n)
#define S3C2440_GPC(n)  (2<<16 | n)
#define S3C2440_GPD(n)  (3<<16 | n)
#define S3C2440_GPE(n)  (4<<16 | n)
#define S3C2440_GPF(n)  (5<<16 | n)
#define S3C2440_GPG(n)  (6<<16 | n)
#define S3C2440_GPH(n)  (7<<16 | n)
#define S3C2440_GPI(n)  (8<<16 | n)
#define S3C2440_GPJ(n)  (9<<16 | n)


/* 分配/设置/注册一个platform_device */

static struct resource led_resource[] = {
    [0] = {
        .start = S3C2440_GPF(5),
        .end   = S3C2440_GPF(5),
        .flags = IORESOURCE_MEM,
    },
};

static void led_release(struct device * dev)
{
}

static struct platform_device led_dev = {
    .name         = "myled",
    .id       = -1,
    .num_resources    = ARRAY_SIZE(led_resource),
    .resource     = led_resource,
    .dev = { 
    	.release = led_release, 
	},
};

static int led_dev_init(void)
{
	platform_device_register(&led_dev);
	return 0;
}

static void led_dev_exit(void)
{
	platform_device_unregister(&led_dev);
}

module_init(led_dev_init);
module_exit(led_dev_exit);

MODULE_LICENSE("GPL");

//led_drv.c，即driver部分

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>

#define S3C2440_GPA(n)  (0<<16 | n)
#define S3C2440_GPB(n)  (1<<16 | n)
#define S3C2440_GPC(n)  (2<<16 | n)
#define S3C2440_GPD(n)  (3<<16 | n)
#define S3C2440_GPE(n)  (4<<16 | n)
#define S3C2440_GPF(n)  (5<<16 | n)
#define S3C2440_GPG(n)  (6<<16 | n)
#define S3C2440_GPH(n)  (7<<16 | n)
#define S3C2440_GPI(n)  (8<<16 | n)
#define S3C2440_GPJ(n)  (9<<16 | n)

static int led_pin;
static volatile unsigned int *gpio_con;
static volatile unsigned int *gpio_dat;

/* 123. 分配/设置/注册file_operations 
 * 4. 入口
 * 5. 出口
 */

static int major;
static struct class *led_class;

static unsigned int gpio_base[] = {
	0x56000000, /* GPACON */
	0x56000010, /* GPBCON */
	0x56000020, /* GPCCON */
	0x56000030, /* GPDCON */
	0x56000040, /* GPECON */
	0x56000050, /* GPFCON */
	0x56000060, /* GPGCON */
	0x56000070, /* GPHCON */
	0,          /* GPICON */
	0x560000D0, /* GPJCON */
};

static int led_open (struct inode *node, struct file *filp)
{
	/* 把LED引脚配置为输出引脚 */
	/* GPF5 - 0x56000050 */
	int bank = led_pin >> 16;
	int base = gpio_base[bank];

	int pin = led_pin & 0xffff;
	gpio_con = ioremap(base, 8);
	if (gpio_con) {
		printk("ioremap(0x%x) = 0x%x\n", base, gpio_con);
	}
	else {
		return -EINVAL;
	}
	
	gpio_dat = gpio_con + 1;

	*gpio_con &= ~(3<<(pin * 2));
	*gpio_con |= (1<<(pin * 2));  

	return 0;
}

static ssize_t led_write (struct file *filp, const char __user *buf, size_t size, loff_t *off)
{
	/* 根据APP传入的值来设置LED引脚 */
	unsigned char val;
	int pin = led_pin & 0xffff;
	
	copy_from_user(&val, buf, 1);

	if (val)
	{
		/* 点灯 */
		*gpio_dat &= ~(1<<pin);
	}
	else
	{
		/* 灭灯 */
		*gpio_dat |= (1<<pin);
	}

	return 1; /* 已写入1个数据 */
}

static int led_release (struct inode *node, struct file *filp)
{
	printk("iounmap(0x%x)\n", gpio_con);
	iounmap(gpio_con);
	return 0;
}


static struct file_operations myled_oprs = {
	.owner = THIS_MODULE,
	.open  = led_open,
	.write = led_write,
	.release = led_release,
};


static int led_probe(struct platform_device *pdev)
{
	struct resource		*res;

	/* 根据platform_device的资源进行ioremap */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	led_pin = res->start;

	major = register_chrdev(0, "myled", &myled_oprs);

	led_class = class_create(THIS_MODULE, "myled");
	device_create(led_class, NULL, MKDEV(major, 0), NULL, "led"); /* /dev/led */
	
	return 0;
}

static int led_remove(struct platform_device *pdev)
{
	unregister_chrdev(major, "myled");
	device_destroy(led_class,  MKDEV(major, 0));
	class_destroy(led_class);
	
	return 0;
}

struct platform_driver led_drv = {
	.probe		= led_probe,
	.remove		= led_remove,
	.driver		= {
		.name	= "myled",
	}
};


static int myled_init(void)
{
	platform_driver_register(&led_drv);
	return 0;
}

static void myled_exit(void)
{
	platform_driver_unregister(&led_drv);
}

module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");

四、使用设备树时对应的驱动编程

a. 使用"总线设备驱动模型"编写的驱动程序分为platform_device和platform_driver两部分
 platform_device : 指定硬件资源, 来自.c文件
 platform_driver : 根据与之匹配的platform_device获得硬件资源, 并分配/设置/注册file_operations

b. 实际上platform_device也可以来自设备树文件.dts
 dts文件被编译为dtb文件,
 dtb文件会传给内核,
 内核会解析dtb文件, 构造出一系列的device_node结构体,
 device_node结构体会转换为platform_device结构体

  所以: 我们可以在dts文件中指定资源, 不再需要在.c文件中设置platform_device结构体

c. “来自dts的platform_device结构体” 与 “我们写的platform_driver” 的匹配过程:

   “来自dts的platform_device结构体"里面有成员”.dev.of_node", 它里面含有各种属性, 比如 compatible, reg, pin

  “我们写的platform_driver"里面有成员”.driver.of_match_table", 它表示能支持哪些来自于dts的platform_device

  如果"of_node中的compatible" 跟 “of_match_table中的compatible” 一致, 就表示匹配成功, 则调用 platform_driver中的probe函数;

  在probe函数中, 可以继续从of_node中获得各种属性来确定硬件资源
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验方法:
1. 编译设备树文件jz2440.dts得到jz2440.dtb
   
   假设内核目录为: /work/system/linux-4.19-rc3/
   
   设置PATH使用新工具链:
   export  PATH=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/work/system/gcc-linaro-4.9.4-2017.01-x86_64_arm-linux-gnueabi/bin
   
   把jz2440.dts复制到内核目录:
   cp jz2440.dts  /work/system/linux-4.19-rc3/arch/arm/boot/dts
   
   编译设备树:
   cd /work/system/linux-4.19-rc3/
   make dtbs
   
   得到 /work/system/linux-4.19-rc3/arch/arm/boot/dts/jz2440.dtb
   
   把dtb文件复制到nfs目录, 假设为 /work/nfs_root

2. 使用jz2440.dtb启动内核

   启动板子进入u-boot :
   
   从NFS下载dtb: 
   nfs 32000000 192.168.1.123:/work/nfs_root/jz2440.dtb
   
   烧写到nand flash:
   nand erase device_tree; nand write.jffs2 32000000 device_tree
   
   重启单板


3. 编译led_drv.c

   设置PATH使用新工具链:
   export  PATH=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/work/system/gcc-linaro-4.9.4-2017.01-x86_64_arm-linux-gnueabi/bin

   cd 001th/driver  或  cd 002th/driver
   
   make  // 得到led_drv.ko
   
4. 编译app ledtest
   
   注意！注意！注意！注意！注意！注意！注意！注意！
   编译APP用的工具链不一样！！！！
   
   设置PATH使用新工具链:
   export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/local/arm/4.3.2/bin
   
   arm-linux-gcc -o ledtest ledtest.c

5. 测试
   在单板上通过nfs得到led_drv.ko和ledtest
   
   测试命令:
   insmod led_drv.ko
   ./ledtest on
   ./ledtest off

//001th
// SPDX-License-Identifier: GPL-2.0
/*
 * SAMSUNG SMDK2440 board device tree source
 *
 * Copyright (c) 2018 weidongshan@qq.com
 * dtc -I dtb -O dts -o jz2440.dts jz2440.dtb
 */
 
#define S3C2410_GPA(_nr)	((0<<16) + (_nr))
#define S3C2410_GPB(_nr)	((1<<16) + (_nr))
#define S3C2410_GPC(_nr)	((2<<16) + (_nr))
#define S3C2410_GPD(_nr)	((3<<16) + (_nr))
#define S3C2410_GPE(_nr)	((4<<16) + (_nr))
#define S3C2410_GPF(_nr)	((5<<16) + (_nr))
#define S3C2410_GPG(_nr)	((6<<16) + (_nr))
#define S3C2410_GPH(_nr)	((7<<16) + (_nr))
#define S3C2410_GPJ(_nr)	((8<<16) + (_nr))
#define S3C2410_GPK(_nr)	((9<<16) + (_nr))
#define S3C2410_GPL(_nr)	((10<<16) + (_nr))
#define S3C2410_GPM(_nr)	((11<<16) + (_nr))

/dts-v1/;

/ {
	model = "SMDK24440";
	compatible = "samsung,smdk2440";

	#address-cells = <1>;
	#size-cells = <1>;
		
	memory@30000000 {
		device_type = "memory";
		reg =  <0x30000000 0x4000000>;
	};
/*
	cpus {
		cpu {
			compatible = "arm,arm926ej-s";
		};
	};
*/	
	chosen {
		bootargs = "noinitrd root=/dev/mtdblock4 rw init=/linuxrc console=ttySAC0,115200";
	};

	
	led {
		compatible = "jz2440_led";
		reg = <S3C2410_GPF(5) 1>;
	};
};

//002th
// SPDX-License-Identifier: GPL-2.0
/*
 * SAMSUNG SMDK2440 board device tree source
 *
 * Copyright (c) 2018 weidongshan@qq.com
 * dtc -I dtb -O dts -o jz2440.dts jz2440.dtb
 */
 
#define S3C2410_GPA(_nr)	((0<<16) + (_nr))
#define S3C2410_GPB(_nr)	((1<<16) + (_nr))
#define S3C2410_GPC(_nr)	((2<<16) + (_nr))
#define S3C2410_GPD(_nr)	((3<<16) + (_nr))
#define S3C2410_GPE(_nr)	((4<<16) + (_nr))
#define S3C2410_GPF(_nr)	((5<<16) + (_nr))
#define S3C2410_GPG(_nr)	((6<<16) + (_nr))
#define S3C2410_GPH(_nr)	((7<<16) + (_nr))
#define S3C2410_GPJ(_nr)	((8<<16) + (_nr))
#define S3C2410_GPK(_nr)	((9<<16) + (_nr))
#define S3C2410_GPL(_nr)	((10<<16) + (_nr))
#define S3C2410_GPM(_nr)	((11<<16) + (_nr))

/dts-v1/;

/ {
	model = "SMDK24440";
	compatible = "samsung,smdk2440";

	#address-cells = <1>;
	#size-cells = <1>;
		
	memory@30000000 {
		device_type = "memory";
		reg =  <0x30000000 0x4000000>;
	};
/*
	cpus {
		cpu {
			compatible = "arm,arm926ej-s";
		};
	};
*/	
	chosen {
		bootargs = "noinitrd root=/dev/mtdblock4 rw init=/linuxrc console=ttySAC0,115200";
	};

	
	led {
		compatible = "jz2440_led";
		pin = <S3C2410_GPF(5)>;
	};
};

//示例代码：001th中的led_drv.c，与上边那个略有不同
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>

#define S3C2440_GPA(n)  (0<<16 | n)
#define S3C2440_GPB(n)  (1<<16 | n)
#define S3C2440_GPC(n)  (2<<16 | n)
#define S3C2440_GPD(n)  (3<<16 | n)
#define S3C2440_GPE(n)  (4<<16 | n)
#define S3C2440_GPF(n)  (5<<16 | n)
#define S3C2440_GPG(n)  (6<<16 | n)
#define S3C2440_GPH(n)  (7<<16 | n)
#define S3C2440_GPI(n)  (8<<16 | n)
#define S3C2440_GPJ(n)  (9<<16 | n)

static int led_pin;
static volatile unsigned int *gpio_con;
static volatile unsigned int *gpio_dat;

/* 123. 分配/设置/注册file_operations 
 * 4. 入口
 * 5. 出口
 */

static int major;
static struct class *led_class;

static unsigned int gpio_base[] = {
	0x56000000, /* GPACON */
	0x56000010, /* GPBCON */
	0x56000020, /* GPCCON */
	0x56000030, /* GPDCON */
	0x56000040, /* GPECON */
	0x56000050, /* GPFCON */
	0x56000060, /* GPGCON */
	0x56000070, /* GPHCON */
	0,          /* GPICON */
	0x560000D0, /* GPJCON */
};

static int led_open (struct inode *node, struct file *filp)
{
	/* 把LED引脚配置为输出引脚 */
	/* GPF5 - 0x56000050 */
	int bank = led_pin >> 16;
	int base = gpio_base[bank];

	int pin = led_pin & 0xffff;
	gpio_con = ioremap(base, 8);
	if (gpio_con) {
		printk("ioremap(0x%x) = 0x%x\n", base, gpio_con);
	}
	else {
		return -EINVAL;
	}
	
	gpio_dat = gpio_con + 1;

	*gpio_con &= ~(3<<(pin * 2));
	*gpio_con |= (1<<(pin * 2));  

	return 0;
}

static ssize_t led_write (struct file *filp, const char __user *buf, size_t size, loff_t *off)
{
	/* 根据APP传入的值来设置LED引脚 */
	unsigned char val;
	int pin = led_pin & 0xffff;
	
	copy_from_user(&val, buf, 1);

	if (val)
	{
		/* 点灯 */
		*gpio_dat &= ~(1<<pin);
	}
	else
	{
		/* 灭灯 */
		*gpio_dat |= (1<<pin);
	}

	return 1; /* 已写入1个数据 */
}

static int led_release (struct inode *node, struct file *filp)
{
	printk("iounmap(0x%x)\n", gpio_con);
	iounmap(gpio_con);
	return 0;
}


static struct file_operations myled_oprs = {
	.owner = THIS_MODULE,
	.open  = led_open,
	.write = led_write,
	.release = led_release,
};


static int led_probe(struct platform_device *pdev)
{
	struct resource		*res;

	/* 根据platform_device的资源进行ioremap */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	led_pin = res->start;

	major = register_chrdev(0, "myled", &myled_oprs);

	led_class = class_create(THIS_MODULE, "myled");
	device_create(led_class, NULL, MKDEV(major, 0), NULL, "led"); /* /dev/led */
	
	return 0;
}

static int led_remove(struct platform_device *pdev)
{
	unregister_chrdev(major, "myled");
	device_destroy(led_class,  MKDEV(major, 0));
	class_destroy(led_class);
	
	return 0;
}

/************************本部分内容是与总线设备驱动模型的led_drv.c不同的地方*********************/
static const struct of_device_id of_match_leds[] = {
	{ .compatible = "jz2440_led", .data = NULL },
	{ /* sentinel */ }
};


struct platform_driver led_drv = {
	.probe		= led_probe,
	.remove		= led_remove,
	.driver		= {
		.name	= "myled",
		.of_match_table = of_match_leds, /* 能支持哪些来自于dts的platform_device */
	}
};

/************************本部分内容是与总线设备驱动模型的led_drv.c不同的地方*********************/

static int myled_init(void)
{
	platform_driver_register(&led_drv);
	return 0;
}

static void myled_exit(void)
{
	platform_driver_unregister(&led_drv);
}
module_init(myled_init);
module_exit(myled_exit);

MODULE_LICENSE("GPL");

002th中的led_drv.c与001中不同之处在于：
在这里插入图片描述

五、只想使用设备树而不想深入研究该如何？

  这是无水之源、无根之木, 只能寄希望于写驱动程序的人: 提供了文档/示例/程序写得好适配性强。

  一个写得好的驱动程序, 它会尽量确定所用资源, 只把不能确定的资源留给设备树, 让设备树来指定。

  根据原理图确定"驱动程序无法确定的硬件资源", 再在设备树文件中填写对应内容那么, 所填写内容的格式是什么?

a. 看文档: 内核 Documentation/devicetree/bindings/
b. 参考同类型单板的设备树文件
c. 网上搜索
d. 实在没办法时, 只能去研究驱动源码

注：本文章参考了《韦东山老师嵌入式课程》笔记，并结合了自己的实际开发经历以及网上他人的技术文章，综合整理得到。如有侵权，联系删除！水平有限，欢迎各位在评论区交流。

小嵌同学
关注
专栏目录
字符设备驱动
10-13
Linux设备驱动PPT，字符设备驱动PPT，真心讲的挺不错的
Linux字符设备驱动实现
11-06
在Linux操作系统中，字符设备驱动是内核与硬件之间交互的关键接口，用于处理特定硬件的输入和输出。本文将深入探讨如何实现一个简单的字符设备驱动，并利用它来设计一个聊天程序，实现进程间的同步通信。 首先，...
Linux内核分析（五）----字符设备驱动实现
weixin_30642561的博客
02-04 142
Linux内核分析（五） 昨天我们对linux内核的子系统进行简单的认识，今天我们正式进入驱动的开发，我们今后的学习为了避免大家没有硬件的缺陷，我们都会以虚拟的设备为例进行学习，所以大家不必害怕没有硬件的问题。 今天我们会分析到以下内容： 1. 字符设备驱动基础 2. 简单字符设备驱动实现 3. 驱动测试 l 字符设备基础 1. 字符...
Linux设备驱动——字符设备的基本驱动实现及关键要素(体系地认识文件与驱动)
最新发布
weixin_56228133的博客
08-19 899
字符(char)设备是个能够像字节流(类似文件)一样被访问的设备，比如字符终端(/dev/console)和串口(/dev/ttys0)，它们可以通过文件系统节点来访问，大多数字符设备是一个个只能顺序访问的数据通道。字符驱动设备程序适合于大多数简单的硬件设备，且比起块设备或网络驱动设备程序的架构相对简洁。在深入了解设备驱动程序时，从字符设备开始剖析可以更好地理解内核的工作过程。
【设备树笔记整理1】字符设备驱动程序的三种写法
qq_23174771的博客
04-24 247
字符设备驱动程序的三种写法
字符设备驱动的几种写法
Leon的博客
01-19 692
随着linux内核的更新换代和计算机硬件的不断增多，字符设备驱动在不同内核版本下也呈现出了几种不同的写法，本文将具体随着linux发展的脚步详述字符设备驱动写法的更新。 在Linux2.4以前，内核中所有已分配的字符设备编号都记录在一个名为 chrdevs ，元素个数为255的散列表里。该散列表中的每一个元素是一个 char_device_struct 结构，代表主设备号相同的一组设备。它在内核中的定义如下： static struct char_device_struct { struct
字符驱动之：实现读写
老鹏
08-25 3450
在linux驱动中实现字符设备的读和写。
Linux内核设备驱动之字符设备驱动笔记整理
09-15
【字符设备驱动详解】 字符设备驱动是Linux内核设备驱动的一部分，主要负责处理那些以字节流方式访问的硬件设备，如串口、并口...理解和掌握字符设备驱动的原理与实现，对于开发和调试Linux系统的硬件驱动至关重要。
Linux字符设备驱动框架
01-29
字符设备是Linux三大设备...编写一个外部模块的字符设备驱动，除了要实现编写一个模块所需要的代码之外，还需要编写作为一个字符设备的代码。 Linux一切皆文件，那么作为一个设备文件，它的操作方法接口封装在structfi
基于linux系统的字符设备驱动研究与设计.pdf
09-06
本文主要研究了Linux系统下的字符设备驱动的设计和实现，详细介绍了字符设备驱动的设计方法和实现过程。在Linux系统下，字符设备驱动是一种特殊的设备驱动，它可以控制字符设备的输入/输出操作。字符设备驱动的设计...
虚拟字符设备驱动程序在Linux的实现.pdf
09-06
虚拟字符设备驱动程序，正如文章中提到的，是一种特殊的设备驱动，它并不直接对应于物理硬件，而是通过软件模拟实现。例如，它可以用于创建一个进程间通信的通道，或者提供一个抽象的接口，使得多个设备可以通过相同...
嵌入式系统/ARM技术中的嵌入式Linux字符设备驱动的设计与应用
11-08
摘要：描述了基于嵌入式Linux的字符设备驱动程序的设计方法和实现过程。以电机、数码管、串口和mini键盘的驱动设计为例，详细阐述了嵌入式linux下字符设备驱动设计中的关键技术，包括设备的设备号、设备的操作及设备的注册和卸载等。通过编写相应硬件设备的应用程序，测试设备驱动的正确性。介绍了Troolltech公司开发的开源图形用户界面库-Qt，并使用Qt编程方法设计出良好的人机交互界面。试验结果表明设计的驱动程序完全正确，可以被应用程序使用。 　　1引言 　　随着嵌入式系统的发展，嵌入式 Linux以其稳定性和开放源代码的优点在嵌入式系统的开发中得到广泛应用。越来越多的软硬件厂商使用嵌入式
Linux字符设备驱动实现及测试教程
资源摘要信息:"Linux字符设备驱动实现与测试" Linux字符设备驱动是Linux操作系统中非常重要的组成部分，它负责管理计算机系统中的字符设备，如键盘、鼠标、串口等。字符设备是一种按字节处理数据的设备，在Linux...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小嵌同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值