本文介绍了如何使用xbus和platform构建自定义驱动总线，涉及buses_init(),bus_register(),device_register(),driver_register()等函数，以及platform_device_register(),platform_driver_register()等平台相关函数，展示了设备驱动模型和匹配规则的实现过程。
目录
platform_device_register()函数：平台设备注册
platform_driver_register宏：平台驱动注册
platform_get_resource()函数：平台驱动获取资源
xbus：打造自属的驱动总线
软件和硬件的代码分离，提高程序的复用性。
device结构体：关联硬件代码
driver_devices结构体：关联软件代码
bus_type：统一管理struct device和struct device_driver、match函数指针设置匹配规则。
在struct bus_type里面设置1个链表头，将要管理的一系列struct device通过一个链表串联起来。
在struct bus_type里面设置另1个链表头，将要管理的一系列struct device_driver通过一个链表串联起来。
Linux中各种各样的硬件设备的驱动代码，都会被拆分成两部分（device结构体和device_driver结构体），去关联硬件、软件代码。
设备驱动模型体现分离模型：
即在/sys目录下有bus/xbus/devices、drivers的结构。
buses_init()函数：总线管理
内核启动默认执行，创建名字为“bus”和“system”的kset对象。即/sys/下生成“bus”、“system”目录。
int __init buses_init(void) { bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL); if (!bus_kset) return -ENOMEM; system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj); if (!system_kset) return -ENOMEM; return 0; }
bus_register()函数：总线注册
总线注册。添加新的总线类型。
int bus_register(struct bus_type *bus)函数做了哪些事情：
在/sys/bus下建立xbus目录项（xbus是自定义的名字，设置bus->name = “xbus”即可），并创建属性文件。
在/sys/bus/xbus下建立devices目录项，并创建属性文件。
在/sys/bus/xbus下建立drivers目录项，并创建属性文件。
（如上需要创建3个目录，因此bus_type结构体需要3个kobject）
初始化priv->klist_devices链表头
初始化priv->klist_drivers链表头
device_register()函数：设备注册
设备注册。添加设备，关联硬件相关代码。
int device_register(struct device *dev)函数做了哪些事情：
在/sys/bus/xbus/devices下建立yyy（具体device）目录项（那么struct device里面肯定要包含一个kobject）。
加入bus->priv->devices_kset链表。
加入bus->priv->klist_devices链表。
遍历bus->priv->klist_drivers，执行bus->match来寻找合适的drv。
dev关联driv，执行drv->probe()。
driver_register()函数：驱动注册
驱动注册。添加驱动，关联软件相关代码。
int driver_register(struct device_driver *drv)函数做了哪些事情：
在/sys/bus/xbus/drivers下建立zzz（具体driver）目录项（那么struct device_driver里面肯定要包含一个kobject）。
加入bus->priv->drivers_kset链表。
加入bus->priv->klist_drivers链表。
遍历bus->priv->klist_klist_devices链表，执行bus->match来寻找合适的dev。
dev关联driv，执行drv->probe()。
设备驱动模型框图
bus、dev、drv关系图
实验环节：xbus
xbus.c文件
#include <linux/init.h> #include <linux/module.h> #include <linux/device.h> int xbus_match(struct device *dev, struct device_driver *drv) { /* __FILE__和__func__ 这两个宏是在编译器里面定义的 */ printk(KERN_ALERT "%s-%s\n", __FILE__, __func__); if(!strncmp(dev_name(dev), drv->name, strlen(drv->name))){ printk(KERN_ALERT "dev & drv match\n"); return 1; } return 0; } static struct bus_type xbus = { .name = "xbus", .match = xbus_match, }; EXPORT_SYMBOL(xbus); static int __init xbus_init(void) { int ret; printk(KERN_ALERT "xbus init\n"); ret = bus_register(&xbus); if(ret != 0) return -1; return 0; } static void __exit xbus_exit(void){ printk(KERN_ALERT "xbus exit\n"); bus_unregister(&xbus); } module_init(xbus_init); module_exit(xbus_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("couvrir"); MODULE_DESCRIPTION("led module"); MODULE_ALIAS("led module");
xdev.c文件
#include <linux/init.h> #include <linux/module.h> #include <linux/device.h> extern struct bus_type xbus; void xdev_release(struct device *dev) { printk(KERN_ALERT "%s-%s\n", __FILE__, __func__); } static struct device xdev = { .init_name = "xdev", /* 指明dev属于哪一条总线 */ .bus = &xbus, .release = xdev_release, }; static int __init xdev_init(void) { int ret; printk(KERN_ALERT "xdev init\n"); ret = device_register(&xdev); if(ret != 0) return -1; return 0; } static void __exit xdev_exit(void){ printk(KERN_ALERT "xdev exit\n"); device_unregister(&xdev); } module_init(xdev_init); module_exit(xdev_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("couvrir"); MODULE_DESCRIPTION("led module"); MODULE_ALIAS("led module");
xdrv.c文件
#include <linux/init.h> #include <linux/module.h> #include <linux/device.h> extern struct bus_type xbus; int xdrv_probe(struct device *dev) { /* device和driver关联起来后会调用该函数 */ printk(KERN_ALERT "%s-%s\n", __FILE__, __func__); return 0; } int xdrv_remove(struct device *dev) { printk(KERN_ALERT "%s-%s\n", __FILE__, __func__); return 0; } static struct device_driver xdrv = { .name = "xdev", /* 指明dev属于哪一条总线 */ .bus = &xbus, .probe = xdrv_probe, .remove = xdrv_remove, }; static int __init xdrv_init(void) { int ret; printk(KERN_ALERT "xdrv init\n"); ret = driver_register(&xdrv); if(ret != 0) return -1; return 0; } static void __exit xdrv_exit(void){ printk(KERN_ALERT "xdrv exit\n"); driver_unregister(&xdrv); } module_init(xdrv_init); module_exit(xdrv_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("couvrir"); MODULE_DESCRIPTION("led module"); MODULE_ALIAS("led module");
Makefile文件
KERNEL_DIR=/home/couvrir/桌面/ebf_linux_kernel_6ull_depth1/build_image/build ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- export ARCH CROSS_COMPILE obj-m:=xbus.o xdev.o xdrv.o all: $(MAKE) -C $(KERNEL_DIR) M=$(CURDIR) modules .PHONY:clean copy clean: $(MAKE) -C $(KERNEL_DIR) M=$(CURDIR) clean sudo rm /home/couvrir/桌面/sharedir/*.ko copy: sudo cp *.ko /home/couvrir/桌面/sharedir
执行过程
虚拟机：执行make和make copy。生成.ko文件。
开发板（在挂载目录下执行）：
sudo insmod xbus.ko
观察/sys/bus/下是否有xbus目录，xbus目录下会自动生成device和driver目录项。
sudo insmod xdev.ko
观察/sys/bus/xbus/device/下是否有xdev目录。
sudo insmod xdrv.ko
观察/sys/bus/xbus/driver/下是否有xdrv目录。
sudo rmmod xdrv
sudo rmmod xdev
sudo rmmod xbus
platform：虚拟的驱动总线
platform_device：继承xbus的device，关联硬件代码
platform_driver：继承xbus的device_driver，重设probe函数指针
platform（bus_type）：统一管理、设置match匹配规则（struct platform_device和struct platform_driver）
platform_bus_init()函数：平台总线注册
函数存放在内核/drivers/base/platform.c，帮我们在/sys/bus下创建platform目录项。
在此之前，需要手动调用bus_register()函数去注册一个驱动总线，但该函数就不需要（该函数设备一上电，内核启动就会自动执行），因为函数内部已经自动调用了bus_register()函数。
struct bus_type platform_bus_type = { .name = "platform", .dev_groups = platform_dev_groups, .match = platform_match, .uevent = platform_uevent, .dma_configure = platform_dma_configure, .pm = &platform_dev_pm_ops, }; int __init platform_bus_init(void) { int error; early_platform_cleanup(); error = device_register(&platform_bus); if (error) { put_device(&platform_bus); return error; } error = bus_register(&platform_bus_type); if (error) device_unregister(&platform_bus); of_platform_register_reconfig_notifier(); return error; }
platform_match()函数：设置匹配规则
/** * 假设平台设备id是这样编码的: * “<name><instance>”，其中<name>是设备类型的简短描述，如“pci”或“floppy”，而<instance>是设备的枚举实例，如“0”或“42”。驱动id是简单的“<name>”。 * 因此，从platform_device结构中提取<name>，并将其与驱动程序的名称进行比较。返回它们是否匹配与否。 */ static int platform_match(struct device *dev, struct device_driver *drv) { struct platform_device *pdev = to_platform_device(dev); struct platform_driver *pdrv = to_platform_driver(drv); /* When driver_override is set, only bind to the matching driver */ if (pdev->driver_override) return !strcmp(pdev->driver_override, drv->name); /* Attempt an OF style match first */ if (of_driver_match_device(dev, drv)) return 1; /* Then try ACPI style match */ if (acpi_driver_match_device(dev, drv)) return 1; /* Then try to match against the id table */ if (pdrv->id_table) return platform_match_id(pdrv->id_table, pdev) != NULL; /* fall-back to driver name match */ return (strcmp(pdev->name, drv->name) == 0); }of_driver_match_device(dev, drv)：设备树匹配。
acpi_driver_match_device(dev, drv)：ACPI匹配，平时开发工作很少用到。
platform_match_id(pdrv->id_table, pdev)：id_table匹配。
strcmp(pdev->name, drv->name)：设备名和驱动名匹配。
platform_device_register()函数：平台设备注册
注册总线设备。函数存放在内核/drivers/base/platform.c，函数内部继承了device。
int platform_device_register(struct platform_device *pdev);
platform_driver_register宏：平台驱动注册
#define platform_driver_register(drv) \ __platform_driver_register(drv, THIS_MODULE) extern int __platform_driver_register(struct platform_driver *, struct module *);该宏存放在内核/include/linux/platform_device.h文件中。
注意第一个参数struct platform_driver关联软件部分的代码，此结构体中最重要的是probe成员函数（一定要初始化好，在bus_register()函数参数调用结构体），是真正的模块入口。另外pdrv->id_table也要初始化好。
platform_get_resource()函数：平台驱动获取资源
驱动总线获取资源，用于在软件模块中获取硬件代码的相关数据。该函数存放于内核/drivers/base/platform.c文件。
/** * platform_get_resource - get a resource for a device * @dev: platform device * @type: resource type * @num: resource index */ struct resource *platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num) { int i; for (i = 0; i < dev->num_resources; i++) { struct resource *r = &dev->resource[i]; if (type == resource_type(r) && num-- == 0) return r; } return NULL; }dev：总线设备，就是于pdrv匹配的pdev->dev。
type：要获取的资源类型。
num：就是type类型资源中的第num个。
实验环节：platform
platform_device.c文件
#include <linux/init.h> #include <linux/module.h> #include <linux/mod_devicetable.h> #include <linux/platform_device.h> #define CCM_CCGR1 0x020c406c //时钟控制寄存器 #define IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO04 0x020e006c //GPIO1_04复用功能选择寄存器 #define IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO04 0x020e02f8 //PAD属性设置寄存器 #define GPIO1_GDIR 0x0209c004 //GPIO方向设置寄存器（输入或输出） #define GPIO1_DR 0x0209c000 //GPIO输出状态寄存器 #define REGISTER_LENGTH 4 //寄存器长度（字节） /* 定义总线设备的硬件资源列表 */ static struct resource rled_resource[] = { { .start = CCM_CCGR1, .end = (CCM_CCGR1 + REGISTER_LENGTH -1), .flags = IORESOURCE_MEM, }, { .start = IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO04, .end = (IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO04 + REGISTER_LENGTH -1), .flags = IORESOURCE_MEM, }, { .start = IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO04, .end = (IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO04 + REGISTER_LENGTH -1), .flags = IORESOURCE_MEM, }, { .start = GPIO1_GDIR, .end = (GPIO1_GDIR + REGISTER_LENGTH -1), .flags = IORESOURCE_MEM, }, { .start = GPIO1_DR, .end = (GPIO1_DR + REGISTER_LENGTH -1), .flags = IORESOURCE_MEM, /* 内存资源 */ }, }; static void rled_release(struct device *dev) { printk(KERN_ALERT "led device release!\n"); } /* 定义总线设备 */ static struct platform_device rled_pdev = { /* 本次实验就是根据pdev->name进行配对的 */ .name = "i.mx6ull-rled", /* -代表没有同名设备，否则通过id来区分同名设备 */ .id = -1, .dev.release = rled_release, .num_resources = ARRAY_SIZE(rled_resource), .resource = rled_resource, }; static int __init led_device_init(void){ printk(KERN_ALERT "led_device_init\n"); platform_device_register(&rled_pdev); return 0; } static void __exit led_device_exit(void){ platform_device_unregister(&rled_pdev); } module_init(led_device_init); module_exit(led_device_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("couvrir"); MODULE_DESCRIPTION("led module"); MODULE_ALIAS("led module");
platform_driver.c文件
#include <linux/init.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> #include <linux/uaccess.h> #include <asm/io.h> #include <linux/mod_devicetable.h> #include <linux/platform_device.h> #include <linux/device.h> #define DEV_MAJOR 0 /* 动态申请主设备号 */ #define DEV_NAME "red_led" /* led设备名字 */ /* GPIO虚拟地址指针 */ static void __iomem *IMX6U_CCM_CCGR1; static void __iomem *SW_MUX_GPIO1_IO04; static void __iomem *SW_PAD_GPIO1_IO04; static void __iomem *GPIO1_GDIR; static void __iomem *GPIO1_DR; static int led_open(struct inode *inode, struct file *filp) { return 0; } static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) { return -EFAULT; } static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt) { unsigned char databuf[10]; if(cnt > 10) cnt = 10; /* 从用户空间拷贝数据到内核空间 */ if(copy_from_user(databuf, buf, cnt)){ return -EIO; } if(!memcmp(databuf, "on", 2)){ iowrite32(0 << 4,GPIO1_DR); }else if(!memcmp(databuf, "off", 3)){ iowrite32(1 << 4,GPIO1_DR); } /* 写成功后，返回写入的字数 */ return cnt; } static int led_release(struct inode *inode, struct file *filp) { return 0; } static struct file_operations led_fops = { .owner = THIS_MODULE, .open = led_open, .read = led_read, .write = led_write, .release = led_release, }; int major = 0; struct class *class_led; static int led_probe(struct platform_device *pdev) { struct resource *mem_ccm_ccgrx; struct resource *mem_iomuxc_mux; struct resource *mem_iomux_pad; struct resource *mem_gdir; struct resource *mem_dr; printk(KERN_ALERT "led_probe\n"); /* 获取匹配的pdev的硬件资源 */ mem_ccm_ccgrx = platform_get_resource(pdev, IORESOURCE_MEM, 0); mem_iomuxc_mux = platform_get_resource(pdev, IORESOURCE_MEM, 1); mem_iomux_pad = platform_get_resource(pdev, IORESOURCE_MEM, 2); mem_gdir = platform_get_resource(pdev, IORESOURCE_MEM, 3); mem_dr = platform_get_resource(pdev, IORESOURCE_MEM, 4); /* GPIO相关寄存器的映射 */ IMX6U_CCM_CCGR1 = ioremap(mem_ccm_ccgrx->start, resource_size(mem_ccm_ccgrx)); SW_MUX_GPIO1_IO04 = ioremap(mem_iomuxc_mux->start, resource_size(mem_iomuxc_mux)); SW_PAD_GPIO1_IO04 = ioremap(mem_iomux_pad->start, resource_size(mem_iomux_pad)); GPIO1_GDIR = ioremap(mem_gdir->start, resource_size(mem_gdir)); GPIO1_DR = ioremap(mem_dr->start, resource_size(mem_dr)); iowrite32(0xffffffff, IMX6U_CCM_CCGR1); iowrite32(5, SW_MUX_GPIO1_IO04); iowrite32(0x10b0, SW_PAD_GPIO1_IO04); iowrite32(1 << 4, GPIO1_GDIR); /* 注册字符设备驱动 */ major = register_chrdev(DEV_MAJOR, DEV_NAME, &led_fops); printk(KERN_ALERT "led major:%d\n", major); /* 创建/sys/class/xxx目录项 */ class_led = class_create(THIS_MODULE, "xxx"); /* 创建/sys/class/xxx/my_led目录项,并生成dev属性文件 */ device_create(class_led, NULL, MKDEV(major, 0), NULL, "my_led"); return 0; } static int led_remove(struct platform_device *dev) { /* 取消映射 */ iounmap(IMX6U_CCM_CCGR1); iounmap(SW_MUX_GPIO1_IO04); iounmap(SW_PAD_GPIO1_IO04); iounmap(GPIO1_GDIR); iounmap(GPIO1_DR); /* 注销字符设备驱动 */ unregister_chrdev(major, DEV_NAME); /* 销毁/sys/class/xxx/my_led目录项 */ device_destroy(class_led, MKDEV(major, 0)); /* 销毁/sys/class/xxx目录项 */ class_destroy(class_led); return 0; } /* 与平台设备文件名匹配 */ static struct platform_device_id led_ids[] = { {.name = "i.mx6ull-rled"}, {} }; /* 定义总线驱动 */ static struct platform_driver led_driver = { /* 本次实验就是根据pdev->name进行配对的 */ .driver.name = "i.mx6ull-rled", .probe = led_probe, .remove = led_remove, .id_table = led_ids, }; static int __init led_driver_init(void){ printk(KERN_ALERT "led_driver_init\n"); return platform_driver_register(&led_driver); } static void __exit led_driver_exit(void){ platform_driver_unregister(&led_driver); } module_init(led_driver_init); module_exit(led_driver_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("couvrir"); MODULE_DESCRIPTION("led module"); MODULE_ALIAS("led module");
Makefile文件
照旧
执行过程
虚拟机：执行make和make copy。生成.ko文件。
开发板（在挂载目录下执行）：
sudo insmod platform_device.ko
sudo insmod platform_driver.ko
ls /dev/my_led
sudo sh -c "echo on > /dev/my_led"
sudo sh -c "echo off > /dev/my_led"
sudo rmmod platform_devicesudo rmmod platform_driver
扫一扫
1240
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
