一、Linux 驱动的分离与分层
1. 驱动的分隔和分离
现在有三个平台,A、B 和 C,这三个平台都有 MPU6050 设备。编写最简单的驱动框架如下图:
每个平台下都有一个主机驱动和设备驱动,主机驱动是必要的,因为不同的平台 I2C 控制器不同。但设备驱动不建议这样。最好的方法是:每个平台的 IC2 控制器都提供一个统一的接口(主机驱动),每个设备只提供一个驱动程序(设备驱动):
因为不止这一个 MPU6050 这一个设备,所以实际的驱动框架如下:
这就是驱动的分隔,将主机驱动和设备驱动分隔开。一般 I2C 的主机驱动已经由半导体厂商写好,设备驱动一般由设备厂家写好,我们只需要提供设备信息即可,比如 I2C 设备就提供设备连接到哪个 I2C 接口上,I2C 的速度是多少等等。 相当于将设备信息从设备驱动中剥离开来,驱动使用标准方法去获取到设备信息(比如从设备树中获取到设备信息),然后根据获取到的设备信息来初始化设备。这相当于驱动只负责驱动,设备只负责设备。
当我们需要向系统注册一个驱动的时候,总线就会在右侧的设备中去寻找,看有没有与之匹配的设备,如果有则关联起来。同样的,向系统注册一个设备的时候,总线会在左侧的驱动中查找看有没有与之匹配的设备,有的话也连接起来。
2. 驱动的分层
驱动的分层的目的是为了在不同的层处理不同的内容。
input 子系统负责管理所有跟输入有关的驱动,包括键盘、鼠标、触摸等等,最底层的就是设备原始驱动,负责获取输入设备的原始值,并把获取到的输入事件上报给 input 核心层。input 核心层会处理各种 IO 模型,并且提供 file_opeartions 操作集合。我们在编写输入设备驱动的时候只需要处理好输入事件的上报即可。
二、platform 平台驱动模型简介
驱动分离里有 总线(bus)、驱动(driver)和设备(device)模型。有些 SOC 外设没有总线,所有 Linux 提出了 platform 虚拟总线,相应就有 platform_bus、platform_driver 和 platform_device。
1. platform 总线
Linux 系统内核使用 bus_type
结构体表示总线,bus_type 结构体内容如下:
struct bus_type {
const char *name;
const char *dev_name;
struct device *dev_root;
const struct attribute_group **bus_groups;
const struct attribute_group **dev_groups;
const struct attribute_group **drv_groups;
int (*match)(struct device *dev, struct device_driver *drv);
int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
int (*probe)(struct device *dev);
int (*remove)(struct device *dev);
void (*shutdown)(struct device *dev);
int (*online)(struct device *dev);
int (*offline)(struct device *dev);
int (*suspend)(struct device *dev, pm_message_t state);
int (*resume)(struct device *dev);
int (*num_vf)(struct device *dev);
int (*dma_configure)(struct device *dev);
const struct dev_pm_ops *pm;
const struct iommu_ops *iommu_ops;
struct subsys_private *p;
struct lock_class_key lock_key;
bool need_parent_lock;
};
其中,match
函数很重要,它是用来完成设备和驱动之间相互匹配。总线是使用 match
函数来根据注册的设备查找对应的的驱动,或者根据驱动查找对应的设备,所以每条总线都要用这个函数。
match 函数有两个参数:dev
和 drv
,两个参数分别为 device 和 device_driver 类型,也就是设备和驱动。
设备和驱动如何匹配?来看一下 platform_match
函数:
static int platform_match(struct device *dev, struct device_driver *drv)
{
struct platform_device *pdev = to_platform_device(dev); // 将device结构体转化为platform_device结构体
struct platform_driver *pdrv = to_platform_driver(drv);
/* 当 driver_override 设置时,只与匹配的驱动程序绑定 */
if (pdev->driver_override)
return !strcmp(pdev->driver_override, drv->name);
/* 首先尝试 OF 样式匹配,of_match_table有个成员变量compatible,里面存放驱动的匹配表
设备树中的每个设备节点的 compatible 属性会和 of_match_table 表中的所有成员比较,
如果有的话就表示设备和此驱动匹配*/
if (of_driver_match_device(dev, drv))
return 1;
/* 然后尝试 ACPI 样式匹配 */
if (acpi_driver_match_device(dev, drv))
return 1;
/* 尝试使用 id 表进行匹配,因为之前把device_driver转化为platform_driver结构体,它里面有个
id_table的成员变量,变量里保存了很多的id信息,id信息存放着platformd驱动所支持的驱动类型*/
if (pdrv->id_table)
return platform_match_id(pdrv->id_table, pdev) != NULL;
/* 回退到驱动程序名称匹配,第三种方式不行之间比较驱动和设备name字段,看是否匹配 */
return (strcmp(pdev->name, drv->name) == 0);
}
2. platform 驱动
platform_driver
结构体表示 platform 驱动,以下是 platform_driver 结构体内容:
struct platform_driver {
int (*probe)(struct platform_device *); // 当驱动与设备匹配成功后probe函数会执行,如果自己要编全新的驱动,probe需要自行实现
int (*remove)(struct platform_device *);
void (*shutdown)(struct platform_device *);
int (*suspend)(struct platform_device *, pm_message_t state);
int (*resume)(struct platform_device *);
struct device_driver driver; // driver是device_deriver的结构体变量,Linux内核大量使用面向对象的思想。
// device_driver相当于基类,提供最基础的驱动框架,platform_driver继承这个基类,又在原有的基础上添加成员变量
const struct platform_device_id *id_table; // id_table类似于表,每个元素类型都是platform_device_id
bool prevent_deferred_probe;
};
在编写 platform
驱动的时候,首先得定义一个 platform_driver
结构体变量,虽然每个成员变量都要实现,但重点实现匹配方法
和 probe 函数
。当驱动和设备匹配成功后 probe 函数会自动执行,具体的驱动程序在 probe 函数中编写。
当定义好 platform_driver
结构体变量后,需要在驱动入口处调用 platform_driver_register
函数向 Linux 内核注册 platform 驱动。
/*
* @description : 注册platform驱动
* @param - handler : 信号的处理函数
* @return : 负数,失败; 0,成功
*/
int platform_driver_register (struct platform_driver *driver);
platform 驱动框架如下:
struct xxx_dev{
struct cdev cdev;
/* 其他设备结构体成员 */
};
struct xxx_dev xxxdev; /* 定义设备结构体变量 */
static int xxx_open(struct inode *inode, struct file *filp)
{
/* 打开设备时执行的具体操作 */
return 0;
}
static ssize_t xxx_write(struct file *filp, const char __user *buf,
size_t cnt, loff_t *offt)
{
/* 写操作时执行的具体操作 */
return 0;
}
/*
* 字符设备驱动操作集
*/
static struct file_operations xxx_fops = {
.owner = THIS_MODULE,
.open = xxx_open,
.write = xxx_write,
};
/*
* platform 驱动的 probe 函数
* 驱动与设备匹配成功后会执行这个函数
* 之前驱动入口init函数里的字符驱动程序全部放在probe里面
*/
static int xxx_probe(struct platform_device *dev)
{
......
cdev_init(&xxxdev.cdev, &xxx_fops); /* 注册字符设备驱动 */
/* 具体的操作 */
return 0;
}
/*
* platform_driver里的remove成员变量
* 关闭platform驱动的时候,此函数执行
* 之前的exit函数里的字节程序全部放到此处来
*/
static int xxx_remove(struct platform_device *dev)
{
......
cdev_del(&xxxdev.cdev); /* 删除 cdev */
/* 具体的操作 */
return 0;
}
/* 匹配列表
如果使用了设备树将通过此匹配表来进行驱动和设备的匹配 */
static const struct of_device_id xxx_of_match[] = {
{ .compatible = "xxx-gpio" }, // 当设备树中设备节点的 compatible 属性值为“xxx-gpio”的时候此设备就会与此驱动匹配
{ /* Sentinel */ } // 这行是一个标记, of_device_id 表最后一个匹配项必须是空的
};
/*
* platform 平台驱动结构体
* 提供有设备树和无设备树两种匹配方式
*/
static struct platform_driver xxx_driver = {
.driver = {
.name = "xxx", // 传统检查驱动和设备的name是否相投
.of_match_table = xxx_of_match, // 用于设备树下的驱动与设备检查
},
.probe = xxx_probe,
.remove = xxx_remove,
};
/* 驱动入口 */
static int __init xxxdriver_init(void)
{
return platform_driver_register(&xxx_driver); // 注册platform驱动
}
/* 驱动出口 */
static void __exit xxxdriver_exit(void)
{
platform_driver_unregister(&xxx_driver); // 卸载platform驱动
}
module_init(xxxdriver_init); /* 模块初始化 */
module_exit(xxxdriver_exit); /* 模块卸载 */
MODULE_LICENSE("GPL"); /* 模块许可证 */
MODULE_AUTHOR("zuozhongkai"); /* 模块作者 */
platform 驱动并不是独立于字符、块、网络设备驱动的其他种类的驱动,而是为了驱动的分离与分层提出来的一种框架。
总之,platform还是基于传统的字符、块、网络驱动设备,只是套上了platform,目的是使用总线、驱动、设备来实现驱动的分层和分离。
3. platform 设备
platform_device
结构体表示 platform 设备。注意,如果内核支持设备树就不要使用 platform_device 来描述设备,改用设备树去描述。以下是 platform_device 结构体内容:
struct platform_device {
const char *name; // 表示设备名字,在platform驱动中的name字段一样,否则无法匹配到正确的驱动
int id;
bool id_auto;
struct device dev;
u64 platform_dma_mask;
u32 num_resources; // 资源数量
struct resource *resource; // 资源,也是设备信息,比如外设寄存器等。
const struct platform_device_id *id_entry;
char *driver_override; /* 要强制匹配的驱动程序名称 */
/* MFD单元格指针 */
struct mfd_cell *mfd_cell;
/* arch specific additions */
struct pdev_archdata archdata;
};
以下是 resource
结构体内容:
struct resource {
resource_size_t start; // 资源的起始信息
resource_size_t end; // 资源的终止信息
const char *name; // 资源名字
unsigned long flags; // 资源类型
unsigned long desc;
struct resource *parent, *sibling, *child;
};
可选的资源类型都定义在 include/linux/ioport.h 里面:
#define IORESOURCE_BITS 0x000000ff /* Bus-specific bits */
#define IORESOURCE_TYPE_BITS 0x00001f00 /* Resource type */
#define IORESOURCE_IO 0x00000100 /* 表示 IO 口的资源 */
#define IORESOURCE_MEM 0x00000200 /* 表示内存地址 */
#define IORESOURCE_REG 0x00000300 /* Register offsets */
#define IORESOURCE_IRQ 0x00000400 /* 中断号 */
#define IORESOURCE_DMA 0x00000800 /* DMA 通道号 */
#define IORESOURCE_BUS 0x00001000 /* 总线号 */
...
#define IORESOURCE_PCI_FIXED (1
注册和销毁设备信息函数如下:
/*
* @description : 注册设备信息到Linux内核
* @param - pdev : 要注册的 platform 设备
* @return : 负数,失败; 0,成功
*/
int platform_device_register(struct platform_device *pdev);
/************************* 分割线 *************************/
/*
* @description : 注销设备信息
* @param - pdev : 要注销的 platform 设备
* @return : 负数,失败; 0,成功
*/
void platform_device_unregister(struct platform_device *pdev);
platfrom 设备信息框架如下:
/*服务器托管网 寄存器地址定义*/
#define PERIPH1_REGISTER_BASE (0X20000000) /* 外设 1 寄存器首地址 */
#define PERIPH2_REGISTER_BASE (0X020E0068) /* 外设 2 寄存器首地址 */
#define REGISTER_LENGTH 4
/* 没有设备树的情况下 */
/* 资源 */
static struct resource xxx_resources[] = { // 这里有两个资源,都是寄存器信息
[0] = {
.start = PERIPH1_REGISTER_BASE,
.end = (PERIPH1_REGISTER_BASE + REGISTER_LENGTH - 1),
.flags = IORESOURCE_MEM, // 这里flag表示内存地址
},
[1] = {
.start = PERIPH2_REGISTER_BASE,
.end = (PERIPH2_REGISTER_BASE + REGISTER_LENGTH - 1),
.flags = IORESOURCE_MEM,
},
};
/* platform设备结构体 */
static struct platform_device xxxdevice = {
.name = "xxx-gpio", // 这里的name字段必须和驱动中的name字段一样
.id = -1,
.num_resources = ARRAY_SIZE(xxx_resources), // 资源大小,ARRAY_SIZE()测量一个数组的元素个数
.resource = xxx_resources,
};
/* 设备模块加载 */
static int __init xxxdevice_init(void)
{
return platform_device_register(&xxxdevice); // 注册platform设备
}
/* 设备模块注销 */
static void __exit xxxdevice_exit(void)
{
platform_device_unregister(&xxxdevice); // 注销platform设备
}
module_init(xxxdevice_init);
module_exit(xxxdevice_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zuozhongkai");
上面这一段代码是不支持设备树的 Linux 版本使用,如果支持设备树后,就不需要用户手动注册 platform 设备,因为设备信息都放到了设备树中去描述,Linux 内核启动的时候就会去设备树中读取设备信息,将其变为 platform_device 形式。
三、程序编写
在 /linux/atk-mpl/Drivers/ 文件夹下新建 17_platform
,并且在里面创建 Vscode 工程,新建 leddevice.c
和 leddriver.c
。
在 leddevice.c 输入以下内容:
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* 寄存器物理地址 */
#define PERIPH_BASE (0x40000000)
#define MPU_AHB4_PERIPH_BASE (PERIPH_BASE + 0x10000000)
#define RCC_BASE (MPU_AHB4_PERIPH_BASE + 0x0000)
#define RCC_MP_AHB4ENSETR (RCC_BASE + 0XA28)
#define GPIOI_BASE (MPU_AHB4_PERIPH_BASE + 0xA000)
#define GPIOI_MODER (GPIOI_BASE + 0x0000)
#define GPIOI_OTYPER (GPIOI_BASE + 0x0004)
#define GPIOI_OSPEEDR (GPIOI_BASE + 0x0008)
#define GPIOI_PUPDR (GPIOI_BASE + 0x000C)
#define GPIOI_BSRR (GPIOI_BASE + 0x0018)
#define REGISTER_LENGTH 4
/* @description : 释放flatform设备模块的时候此函数会执行
* @param - dev : 要释放的设备
* @return : 无
*/
static void led_release(struct device *dev)
{
printk("led device released!rn");
}
/*
* 设备资源信息,也就是LED0所使用的所有寄存器
*/
static struct resource led_resources[] = {
[0] = {
.start = RCC_MP_AHB4ENSETR,
.end = (RCC_MP_AHB4ENSETR + REGISTER_LENGTH - 1),
.flags = IORESOURCE_MEM,
},
[1] = {
.start = GPIOI_MODER,
.end = (GPIOI_MODER +服务器托管网 REGISTER_LENGTH - 1),
.flags = IORESOURCE_MEM,
},
[2] = {
.start = GPIOI_OTYPER,
.end = (GPIOI_OTYPER + REGISTER_LENGTH - 1),
.flags = IORESOURCE_MEM,
},
[3] = {
.start = GPIOI_OSPEEDR,
.end = (GPIOI_OSPEEDR + REGISTER_LENGTH - 1),
.flags = IORESOURCE_MEM,
},
[4] = {
.start = GPIOI_PUPDR,
.end = (GPIOI_PUPDR + REGISTER_LENGTH - 1),
.flags = IORESOURCE_MEM,
},
[5] = {
.start = GPIOI_BSRR,
.end = (GPIOI_BSRR + REGISTER_LENGTH - 1),
.flags = IORESOURCE_MEM,
},
};
/*
* platform设备结构体
*/
static struct platform_device leddevice = {
.name = "stm32mp1-led", // 这里很重要,设备name和驱动name要相匹配
.id = -1,
.dev = {
.release = &led_release,
},
.num_resources = ARRAY_SIZE(led_resources),
.resource = led_resources,
};
/*
* @description : 设备模块加载
* @param : 无
* @return : 无
*/
static int __init leddevice_init(void)
{
return platform_device_register(&leddevice); // 注册设备
}
/*
* @description : 设备模块注销
* @param : 无
* @return : 无
*/
static void __exit leddevice_exit(void)
{
platform_device_unregister(&leddevice); // 注销设备
}
module_init(leddevice_init);
module_exit(leddevice_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ALIENTEK");
MODULE_INFO(intree, "Y");
编写 leddriver.c 文件:
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define LEDDEV_CNT 1 /* 设备号长度 */
#define LEDDEV_NAME "platled" /* 设备名字 */
#define LEDOFF 0
#define LEDON 1
/* 映射后的寄存器虚拟地址指针 */ // 这里没有用gpio子系统
static void __iomem *MPU_AHB4_PERIPH_RCC_PI;
static void __iomem *GPIOI_MODER_PI;
static void __iomem *GPIOI_OTYPER_PI;
static void __iomem *GPIOI_OSPEEDR_PI;
static void __iomem *GPIOI_PUPDR_PI;
static void __iomem *GPIOI_BSRR_PI;
/* leddev设备结构体 */
struct leddev_dev{
dev_t devid; /* 设备号 */
struct cdev cdev; /* cdev */
struct class *class; /* 类 */
struct device *device; /* 设备 */
};
struct leddev_dev leddev; /* led设备 */
/*
* @description : LED打开/关闭
* @param - sta : LEDON(0) 打开LED,LEDOFF(1) 关闭LED
* @return : 无
*/
void led_switch(u8 sta)
{
u32 val = 0;
if(sta == LEDON) {
val = readl(GPIOI_BSRR_PI);
val |= (1 dev, "No MEM resource for always onn");
return -ENXIO;
}
ressize[i] = resource_size(ledsource[i]);
}
/* 2、初始化LED */
/* 寄存器地址映射 */
MPU_AHB4_PERIPH_RCC_PI = ioremap(ledsource[0]->start, ressize[0]);
GPIOI_MODER_PI = ioremap(ledsource[1]->start, ressize[1]);
GPIOI_OTYPER_PI = ioremap(ledsource[2]->start, ressize[2]);
GPIOI_OSPEEDR_PI = ioremap(ledsource[3]->start, ressize[3]);
GPIOI_PUPDR_PI = ioremap(ledsource[4]->start, ressize[4]);
GPIOI_BSRR_PI = ioremap(ledsource[5]->start, ressize[5]);
/* 3、使能PI时钟 */
val = readl(MPU_AHB4_PERIPH_RCC_PI);
val &= ~(0X1
新建 ledplatformApp.c 并输入以下内容:
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#define LEDOFF 0
#define LEDON 1
/*
* @description : main主程序
* @param - argc : argv数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int fd, retvalue;
char *filename;
unsigned char databuf[1];
if(argc != 3){
printf("Error Usage!rn");
return -1;
}
filename = argv[1];
/* 打开led驱动 */
fd = open(filename, O_RDWR);
if(fd
四、运行测试
编写 Makefile文件:
KERNELDIR := /home/alientek/linux/atk-mpl/linux/my_linux/linux-5.4.31
CURRENT_PATH := $(shell pwd)
obj-m := leddevice.o
obj-m += leddriver.o
build: kernel_modules
kernel_modules:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
编译 leddevice.c 、leddriver.c 和 ledpaltformApp.c 文件:
make
arm-none-linux-gnueabihf-gcc ledplatformApp.c -o ledplatformApp
将编译好的 leddevice.ko、leddriver.ko 和 ledplatformApp 复制:
sudo cp ledplatformApp leddevice.ko leddriver.ko /home/alientek/linux/nfs/rootfs/lib/modules/5.4.31/ -f
开启开发板,输入以下命令:
cd lib/modules/5.4.31/
depmod
modprobe leddevice.ko # 加载设备模块
modprobe leddriver.ko # 加载驱动模块
之后会看到这样的消息:
led 驱动和设备驱动匹配成功。
在 /sys/bus/platform/driver 目录下可以看到 stm32mp1-led 驱动文件:
在 /sys/bus/platform/device 目录下可以看到 stm32mp1-led 设备文件:
测试 LED 驱动:
./ledplatformApp /dev/platled 1 # 点亮
./ledplatformApp /dev/platled 0 # 熄灭
卸载驱动:
rmmod leddevice.ko
rmmod leddriver.ko
总结
这章起始不必太过关注没有设备树部分,关注为什么要有 platform 平台,因为需要把设备和驱动分开,一种更好的框架。
服务器托管,北京服务器托管,服务器租用 http://www.fwqtg.net
相关推荐: 212-jquery 查找div 不为某个class的,且同时包含另外一个class的
服务器托管网 jquery查找下一个class jQuery 父级元素 服务器托管网 选择器 服务器托管,北京服务器托管,服务器租用 http://www.fwqtg.net 机房租用,北京机房租用,IDC机房托管, http://www.fwqtg.net相…