【Linux 平台总线驱动开发实战】

在 Linux 驱动开发领域，平台总线驱动是连接硬件设备与内核的重要桥梁，它通过将设备和驱动分离管理，极大提升了驱动的复用性和系统的可维护性。本文将深入剖析平台总线驱动的工作原理，并结合完整代码示例，帮助开发者掌握其核心开发流程。

一、平台总线驱动基础概念

Linux 平台总线驱动基于设备、驱动和总线三者的协同工作，形成了一套高效的设备管理机制：

设备（Device）： 代表具体的硬件实体，描述设备名称、资源占用（如内存地址、中断号）等信息。 驱动（Driver）： 包含操作硬件的核心代码，通过probe、remove等回调函数完成设备初始化与资源释放。 总线（Bus）： 负责两者的注册、匹配与通信，确保驱动能正确识别并控制设备。

平台总线的核心优势在于分离设备与驱动，同一驱动可适配多种同类设备，设备升级时仅需修改设备描述，无需改动驱动代码，显著提升开发效率。

二、核心数据结构解析

2.1 设备结构体 struct platform_device

struct platform_device {
    const char  *name;      // 设备名称，用于驱动匹配
    int         id;         // 设备ID（-1表示自动分配）
    struct device dev;      // 通用设备结构
    u32         num_resources;  // 资源数量
    struct resource *resource;  // 硬件资源数组
    // 其他字段
};

通过填充resource数组，可指定设备的内存、中断等资源。例如：

static struct resource my_gpio_resources[] = {
    [0] = {
       .start = 0xFDD60000,       // GPIO控制器基地址
       .end   = 0xFDD60004,
       .flags = IORESOURCE_MEM,
	},
    [1] = {
       .start = 15,       
       .end   = 15,
       .flags = IORESOURCE_IRQ,
	}

};

2.2 驱动结构体 struct platform_driver

struct platform_driver {
    int (*probe)(struct platform_device *);  // 设备匹配成功时调用
    int (*remove)(struct platform_device *); // 设备移除时调用
    struct device_driver driver;             // 通用驱动结构
    const struct platform_device_id *id_table; // 支持的设备ID表
    // 其他字段
};

probe函数是驱动核心，用于初始化设备；id_table定义驱动支持的设备列表，辅助总线完成匹配。

2.3 资源结构体 struct resource

struct resource {
    resource_size_t start;  // 资源起始地址
    resource_size_t end;    // 资源结束地址
    unsigned long flags;    // 资源类型（如`IORESOURCE_MEM`、`IORESOURCE_IRQ`）
    // 其他字段
};

三、驱动开发完整流程

3.1 设备注册

定义设备资源： 通过struct resource数组描述硬件资源。 初始化设备结构体： 填充struct platform_device，指定名称、ID 和资源。 注册设备到总线： 调用platform_device_register函数。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/ioport.h>

// 设备名称（用于匹配驱动）
#define DEVICE_NAME "my_gpio_controller"

// 定义设备资源（内存区域和中断）
static struct resource my_gpio_resources[] = {
    [0] = {
       .start = 0xFDD60000,       // GPIO控制器基地址
       .end   = 0xFDD60004,
       .flags = IORESOURCE_MEM,
	},
    [1] = {
       .start = 15,       
       .end   = 15,
       .flags = IORESOURCE_IRQ,
	}

};

static void my_gpio_release(struct device *dev){
    
    printk(KERN_ERR "my_gpio_release\n");
}

// 平台设备结构体
static struct platform_device my_gpio_device = {
    .name           = DEVICE_NAME,
    .id             = -1,          // 自动分配ID
    .num_resources  = ARRAY_SIZE(my_gpio_resources),
    .resource       = my_gpio_resources,
    .dev            = {
        .release    = my_gpio_release
    },
};

// 模块初始化函数
static int __init platform_device_init(void) {
    int ret;
    
    // 注册平台设备
    ret = platform_device_register(&my_gpio_device);
    if (ret) {
        printk(KERN_ERR "Failed to register platform device: %d\n", ret);
        return ret;
    }
    
    printk(KERN_INFO "Platform device registered: %s\n", DEVICE_NAME);
    return 0;
}

// 模块退出函数
static void __exit platform_device_exit(void) {
    // 注销平台设备
    platform_device_unregister(&my_gpio_device);
    printk(KERN_INFO "Platform device unregistered\n");
}

module_init(platform_device_init);
module_exit(platform_device_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Example Platform Device");
MODULE_AUTHOR("cmy");

3.2 驱动注册

实现驱动回调函数： 编写probe、remove等核心函数。 初始化驱动结构体： 指定驱动名称、支持的设备列表等。 注册驱动到总线： 调用platform_driver_register函数。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/mod_devicetable.h>
#include <linux/device.h>

// 驱动支持的设备名称
#define DRIVER_NAME "my_gpio_controller"

// 寄存器偏移量
#define GPIO_SWPORT_DDR 0x0008 //输入输出偏移量
#define GPIO_SWPORT_DR 0x0000 //高低电平偏移量

// 设备私有数据结构
struct gpio_dev {
    struct device *dev;
    dev_t dev_num;
    void __iomem *regs;         // 映射后的寄存器基址
    int irq;                    // 中断号
    struct class *class;        // 设备类
	struct cdev cdev;			// 字符设备结构
};

// 文件操作函数
static ssize_t gpio_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) {
    struct gpio_dev *gdev = filp->private_data;
    int value = 0;
    
    if (!gdev->regs) 
    {
        printk(KERN_ERR "gpio_read gdev->regs can't be null\n");
        return -EFAULT;
    }
    
        
    u64 gp_cfg = ioread64(gdev->regs + GPIO_SWPORT_DR);
    value = (gp_cfg >> 15) & 1;//获取第15位

    printk(KERN_INFO "gpio_read value = %d\n", value);
    if (copy_to_user(buf, &value, sizeof(int))) {
        return -EFAULT;
    }
    
    return 0;
}

static ssize_t gpio_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) {
    struct gpio_dev *gdev = filp->private_data;
    
	int value = 0;
    if (copy_from_user(&value, buf, sizeof(int))) {
        return -EFAULT;
    }
    if (!gdev->regs) 
    {
        printk(KERN_ERR "gpio_write gdev->regs can't be null\n");
        return -EFAULT;
    }
    
    u64 gp_cfg = ioread64(gdev->regs + GPIO_SWPORT_DR);
    printk(KERN_INFO "gpio_write GPIO_SWPORT_DR gp_cfg = %llx\n", gp_cfg);
    if(value)
    {
        gp_cfg |= 1 << 31;//Write access enable
        gp_cfg |= 1 << 15;//high

    }
    else
    {
        gp_cfg |= 1 << 31;//Write access enable
        printk(KERN_INFO " gpio_write Write access gp_cfg = %llx\n", gp_cfg);
        gp_cfg &= ~(1 << 15);//low
        printk(KERN_INFO " gpio_write low gp_cfg = %llx\n", gp_cfg);
    }

    
    iowrite64(gp_cfg, gdev->regs + GPIO_SWPORT_DR);
    
    printk(KERN_INFO " gpio_write gp_cfg = %llx\n", gp_cfg);

    return 0;
}

static int gpio_open(struct inode *inode, struct file *filp) {
    struct gpio_dev *gdev = container_of(inode->i_cdev, struct gpio_dev, cdev);
    filp->private_data = gdev;
    return 0;
}

static int gpio_release(struct inode *inode, struct file *filp) {
    return 0;
}

// 文件操作表
static const struct file_operations gpio_fops = {
    .owner = THIS_MODULE,
    .open = gpio_open,
    .read = gpio_read,
    .write = gpio_write,
    .release = gpio_release,
};



// 驱动probe函数（设备匹配成功时调用）
static int gpio_probe(struct platform_device *pdev) {
    struct gpio_dev *gdev;
    struct resource *res;
    int ret;
    
    // 分配并初始化设备结构体
    gdev = devm_kzalloc(&pdev->dev, sizeof(*gdev), GFP_KERNEL);
    if (!gdev) {
        dev_err(&pdev->dev, "Failed to allocate memory\n");
        return -ENOMEM;
    }
    
    gdev->dev = &pdev->dev;
    platform_set_drvdata(pdev, gdev);
    
    // 获取内存资源并映射
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    printk(KERN_INFO "gpio_probe res->start = %llx, res->end = %llx\n", res->start, res->end);
    /*if (!res) {
        dev_err(&pdev->dev, "Missing memory resource\n");
        return -ENODEV;
    }
    
    gdev->regs = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(gdev->regs)) {
        dev_err(&pdev->dev, "Failed to map memory resource\n");
        return PTR_ERR(gdev->regs);
    }*/

    
    // 注册字符设备
    ret = alloc_chrdev_region(&gdev->dev_num, 0, 1, pdev->name);
    if (ret) {
        dev_err(&pdev->dev, "Failed to allocate char device region\n");
        return ret;
    }
    
    cdev_init(&gdev->cdev, &gpio_fops);
    gdev->cdev.owner = THIS_MODULE;

    ret = cdev_add(&gdev->cdev, gdev->dev_num, 1);
    if (ret) {
        dev_err(&pdev->dev, "Failed to add char device\n");
        unregister_chrdev_region(gdev->dev_num, 1);
        return ret;
    }
    
    // 创建设备类
    gdev->class = class_create(THIS_MODULE, pdev->name);
    if (IS_ERR(gdev->class)) {
        dev_err(&pdev->dev, "Failed to create class\n");
        cdev_del(&gdev->cdev);
        unregister_chrdev_region(gdev->dev_num, 1);
        return PTR_ERR(gdev->class);
    }
    
    // 创建设备节点
    gdev->dev = device_create(gdev->class, NULL, gdev->dev_num, NULL, pdev->name);
    if (IS_ERR(gdev->dev)) {
        dev_err(&pdev->dev, "Failed to create device\n");
        class_destroy(gdev->class);
        cdev_del(&gdev->cdev);
        unregister_chrdev_region(gdev->dev_num, 1);
        return PTR_ERR(gdev->dev);
    }

    // 映射GPIO寄存器
    gdev->regs = ioremap(res->start, res->end - res->start);
    if (!gdev->regs) {
        printk(KERN_ERR "gpio_probe Failed to ioremap\n");
        cdev_del(&gdev->cdev);
        unregister_chrdev_region(gdev->dev_num, 1);
        return -ENOMEM;
    }
    printk(KERN_INFO "gpio_probe gdev->regs = %llx\n", gdev->regs);


    u64 gp_cfg = ioread64(gdev->regs + GPIO_SWPORT_DDR);
    printk(KERN_INFO "gpio_probe GPIO_SWPORT_DDR gp_cfg = %llx\n", gp_cfg);
    gp_cfg |= 1 << 31;// Write access enable
    gp_cfg |= 1 << 15;//Output

    //设置输出模式
    iowrite64(gp_cfg, gdev->regs + GPIO_SWPORT_DDR);
    gp_cfg = ioread64(gdev->regs + GPIO_SWPORT_DDR);


    printk(KERN_INFO "gpio_probe initialized successfully gp_cfg = %llx\n", gp_cfg);


    
    dev_info(&pdev->dev, "GPIO driver initialized\n");
    return 0;
}

// 驱动remove函数（设备移除时调用）
static int gpio_remove(struct platform_device *pdev) {
    struct gpio_dev *gdev = platform_get_drvdata(pdev);
    if (gdev->regs) {
        iounmap(gdev->regs);  // 解除映射
        gdev->regs = NULL;
    }
    
    // 清理资源
    device_destroy(gdev->class, gdev->dev_num);
    class_destroy(gdev->class);
    cdev_del(&gdev->cdev);
    unregister_chrdev_region(gdev->dev_num, 1);
    
    dev_info(&pdev->dev, "GPIO driver removed\n");
    return 0;
}

// 驱动支持的设备ID表
 const struct platform_device_id gpio_device_id = {
    .name = DRIVER_NAME,
};


// 平台驱动结构体
static struct platform_driver gpio_driver = {
    .probe      = gpio_probe,
    .remove     = gpio_remove,
    .driver     = {
        .name   = DRIVER_NAME,
        .owner  = THIS_MODULE,
    },
    .id_table   = &gpio_device_id,
};

// 模块初始化
static int __init gpio_driver_init(void) {
    return platform_driver_register(&gpio_driver);
}

// 模块退出
static void __exit gpio_driver_exit(void) {
    platform_driver_unregister(&gpio_driver);
}

module_init(gpio_driver_init);
module_exit(gpio_driver_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Example Platform Driver");
MODULE_AUTHOR("cmy");

3.3 设备与驱动匹配

总线通过设备和驱动的name字段进行匹配，匹配成功后自动调用驱动的probe函数初始化设备。若id_table存在，总线会优先检查设备是否在支持列表中。

四、编译与测试

4.1 编译模块

创建Makefile：

export ARCH=arm64

export CROSS_COMPILE=/home/chenmy/rk356x/RK356X_Android11.0/prebuilts/gcc/linux-x86/aarch64/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-

obj-m += platform_device_example.o

obj-m += platform_driver_example.o

KERNEL_DIR:=/home/chenmy/rk356x/RK356X_Android11.0/kernel

all:
	make -C $(KERNEL_DIR) M=$(PWD) modules
clean:
	make -C $(KERNEL_DIR) M=$(PWD) clean

执行make生成.ko模块文件。

4.2 加载与验证

 # 加载设备模块
insmod platform_device_example.ko
# 加载驱动模块
insmod platform_driver_example.ko

# 查看设备与驱动状态
ls /sys/bus/platform/devices | grep "my"
ls /sys/bus/platform/drivers | grep "my"

五、总结

Linux 平台总线驱动通过标准化的设备与驱动分离模型，显著提升了驱动开发的效率与代码复用性。本文通过原理解析与完整代码示例，展示了从设备注册、驱动实现到匹配测试的全流程。在实际开发中，开发者可根据硬件需求灵活调整资源配置与回调函数逻辑，构建稳定高效的驱动程序。