5.linux设备驱动模型：xbus、platform

目录

xbus：打造自属的驱动总线

buses_init()函数

bus_register()函数

device_register()函数

driver_register()函数

设备驱动模型框图

bus、dev、drv关系图

实验环节：xbus

xbus.c文件

xdev.c文件

xdrv.c文件

Makefile文件

执行过程

platform：虚拟的驱动总线

platform_bus_init()函数

platform_match()函数

platform_device_register()函数

platform_driver_register宏

platform_get_resource()函数

实验环节：platform

platform_device.c文件

platform_driver.c文件

Makefile文件

执行过程

---

xbus：打造自属的驱动总线

软件和硬件的代码分离，提高程序的复用性。

device：关联硬件代码

driver_devices：关联软件代码

bus_type：统一管理、设置match匹配规则（struct device和struct device_driver）

在struct bus_type里面设置1个链表头，将要管理的一系列struct device通过一个链表串联起来。

在struct bus_type里面设置另1个链表头，将要管理的一系列struct device_driver通过一个链表串联起来。

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目录项（那么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目录项（那么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 = "xdrv",
        /* 指明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：继承device，关联硬件代码

platform_driver：继承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()函数。 

函数存放在内核/drivers/base/platform.c，帮我们在/sys/bus下创建platform目录项。

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)
{
        device_initialize(&pdev->dev);
        arch_setup_pdev_archdata(pdev);
        return platform_device_add(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_device.ko

sudo rmmod platform_driver.ko