Linux Platform驱动通用框架

1386 字

7 分钟

Linux Platform驱动通用框架

2025-03-28

嵌入式 Linux 开发

Linux

/

Platform驱动

/

Linux驱动

/

设备树

设备树#

Platform驱动需要读取设备树中的compatible信息用于of_match_table进行匹配：

1
/* Custom LED pinctrl */
2
gpioled {
3
  #address-cells = <1>;
4
  #size-cells = <1>;
5
  compatible = "custom-gpioled";
6
  pinctrl-names = "default";
7
  pinctrl-0 = <&pinctrl_led>;
8
  led-gpio = <&gpio1 3 GPIO_ACTIVE_LOW>;
9
  status = "okay";
10
};

Platform驱动#

Platform驱动本质还是传统的字符设备驱动、块设备驱动或网络设备驱动，只是套上了一张”platform”的皮，目的是使用驱动->总线->设备这个驱动框架来实现驱动的分离和分层

Platform设备声明和注册#

需要手动定义一个platform_driver类型的结构体变量，然后实现结构体中的各个成员变量，主要是匹配方法和probe函数。然后，在驱动文件的xxx_open()函数中调用platform_driver_register函数以注册该Platform设备：

1
static struct platform_driver led_driver = {
2
    .driver = {
3
        .name = "imx6ul-led",   //Platform设备名称
4
        .of_match_table = led_of_match, //Platform匹配表
5
    },
6
    .probe = led_probe,     //Probe函数
7
    .remove = led_remove,   //驱动卸载函数
8
};

1
static int __init leddriver_init(void)
2
{
3
    return platform_driver_register(&led_driver);   //初始化设备时注册Platform设备
4
}
5

6
static void __exit leddriver_exit(void)
7
{
8
    platform_driver_unregister(&led_driver);        //关闭设备时卸载Platform设备
9
}

Linux官方会使用module_platform_driver(gpio_led_driver)来向Kernel注册Platform设备，这个宏展开之后为：

1
static int __init gpio_led_driver_init(void)
2
{
3
    return platform_driver_register (&(gpio_led_driver));
4
}
5
module_init(gpio_led_driver_init);
6

7
static void __exit gpio_led_driver_exit(void)
8
{
9
    platform_driver_unregister (&(gpio_led_driver));
10
}
11
module_exit(gpio_led_driver_exit);

这实际上就是标准的注册和删除Platform驱动的步骤，使用这个宏可以大大简化Platform设备的驱动代码。

设备匹配表#

驱动中需要声明一个of_device_id类别的匹配表，用于Platform从设备树查找对应设备：

1
struct of_device_id {
2
    char    name[32];
3
    char    type[32];
4
    char    compatible[128];
5
    const void  *data;
6
}

通常都是使用compatible属性和设备树节点中的compatible值进行比对以进行匹配：

1
/* Platform匹配设备树 */
2
static const struct of_device_id led_of_match[] = {
3
    {.compatible = "custom-gpioled"},
4
};

probe函数#

probe函数在驱动和设备匹配完成后执行，对于字符设备而言，原先在xxx_open中的代码可以移到probe函数中执行，即只在Platform驱动和设备匹配完成后执行，而不是在打开文件后就执行。probe函数的形参为已经声明并且注册过的platform_device类型的结构体

1
/* platfrom函数的probe驱动，匹配后此函数执行 */
2
static int led_probe (struct platform_device *dev)
3
{
4
    printk("LED driver and device has beem matched!\r\n");
5

6
    if (leddev.major){
7
        leddev.devid = MKDEV(leddev.major, 0);
8
        register_chrdev_region(leddev.devid, LEDDEV_CNT, LEDDEV_NAME);
9
    }else{
10
        alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, LEDDEV_NAME);
11
        leddev.major = MAJOR(leddev.devid);
12
        leddev.minor = MINOR(leddev.devid);
13
    }
14
    printk("Device reg ok, major = %d, minor = %d\r\n", leddev.major, leddev.minor);
15

16
    leddev.cdev.owner = THIS_MODULE;
17
    cdev_init(&leddev.cdev, &led_fops);
18
    cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);
19

20
    leddev.class = class_create(LEDDEV_NAME);
21
    if (IS_ERR(leddev.class)){
22
        return PTR_ERR(leddev.class);
23
    }
24

25
    leddev.device = device_create(leddev.class, NULL, leddev.devid, NULL, LEDDEV_NAME);
26
    if (IS_ERR(leddev.device)){
27
        return PTR_ERR(leddev.device);
28
    }
29

30
    leddev.nd = of_find_node_by_path("/gpioled");
31
    if (leddev.nd == NULL){
32
        printk("Unable find node\r\n");
33
        return -EINVAL;
34
    }
35

36
    leddev.led0_gpio = of_get_named_gpio(leddev.nd, "led-gpio", 0);
37
    if (leddev.led0_gpio < 0){
38
        printk("unable find gpio\r\n");
39
        return -EINVAL;
40
    }
41

42
    gpio_request(leddev.led0_gpio, "led0");
43
    gpio_direction_output(leddev.led0_gpio, 1);
44

45
    return 0;
46
}

完整代码示例#

驱动#

1
#include <linux/types.h>
2
#include <linux/kernel.h>
3
#include <linux/delay.h>
4
#include <linux/libata.h>   /* 新版kernel不再支持ide.h */
5
#include <linux/init.h>
6
#include <linux/module.h>
7
#include <linux/errno.h>
8
#include <linux/gpio.h>
9
#include <linux/cdev.h>
10
#include <linux/device.h>
11
#include <linux/of.h>
12
#include <linux/wait.h>
13
#include <linux/poll.h>
14
#include <linux/of_address.h>
15
#include <linux/of_gpio.h>
16
#include <asm/mach/map.h>
17
#include <asm/uaccess.h>
18
#include <asm/io.h>
19
#include <linux/semaphore.h>
20
#include <linux/timer.h>
21
#include <linux/of_irq.h>
22
#include <linux/irq.h>
23
#include <linux/fcntl.h>
24
#include <linux/fs.h>
25
#include <linux/platform_device.h>
26

27
#define LEDDEV_CNT      1
28
#define LEDDEV_NAME     "dtsplatled"
29
#define LEDOFF          0
30
#define LEDON           1
31

32
struct leddev_dev {
33
    dev_t   devid;
34
    struct cdev cdev;
35
    struct class *class;
36
    struct device *device;
37
    int major;
38
    int minor;
39
    struct device_node *nd;
40
    int led0_gpio;
41
};
42

43
struct leddev_dev   leddev;
44

45
void led0_switch(u8 sta)
46
{
47
    switch (sta)
48
    {
49
    case LEDON:
50
        gpio_set_value(leddev.led0_gpio, 0);
51
        break;
52

53
    case LEDOFF:
54
        gpio_set_value(leddev.led0_gpio, 1);
55
        break;
56
    }
57
}
58

59
static int led_open(struct inode *inode, struct file *filp)
60
{
61
    filp->private_data = (struct leddev_dev *)&leddev;
62
    return 0;
63
}
64

65
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
66
{
67
    int ret;
68
    unsigned char databuf[2];
69
    unsigned char led_sta;
70

71
    ret = copy_from_user(databuf, buf, cnt);
72
    if (ret < 0){
73
        printk("copy from user failed\r\n");
74
        return -EFAULT;
75
    }
76

77
    led_sta = databuf[0];
78
    switch (led_sta)
79
    {
80
    case LEDON:
81
        led0_switch(LEDON);
82
        break;
83

84
    case LEDOFF:
85
        led0_switch(LEDOFF);
86
        break;
87
    }
88
    return 0;
89
}
90

91
static struct file_operations led_fops = {
92
    .owner = THIS_MODULE,
93
    .open = led_open,
94
    .write = led_write,
95
};
96

97
/* platfrom函数的probe驱动，匹配后此函数执行 */
98
static int led_probe (struct platform_device *dev)
99
{
100
    printk("LED driver and device has beem matched!\r\n");
101

102
    if (leddev.major){
103
        leddev.devid = MKDEV(leddev.major, 0);
104
        register_chrdev_region(leddev.devid, LEDDEV_CNT, LEDDEV_NAME);
105
    }else{
106
        alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, LEDDEV_NAME);
107
        leddev.major = MAJOR(leddev.devid);
108
        leddev.minor = MINOR(leddev.devid);
109
    }
110
    printk("Device reg ok, major = %d, minor = %d\r\n", leddev.major, leddev.minor);
111

112
    leddev.cdev.owner = THIS_MODULE;
113
    cdev_init(&leddev.cdev, &led_fops);
114
    cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);
115

116
    leddev.class = class_create(LEDDEV_NAME);
117
    if (IS_ERR(leddev.class)){
118
        return PTR_ERR(leddev.class);
119
    }
120

121
    leddev.device = device_create(leddev.class, NULL, leddev.devid, NULL, LEDDEV_NAME);
122
    if (IS_ERR(leddev.device)){
123
        return PTR_ERR(leddev.device);
124
    }
125

126
    leddev.nd = of_find_node_by_path("/gpioled");
127
    if (leddev.nd == NULL){
128
        printk("Unable find node\r\n");
129
        return -EINVAL;
130
    }
131

132
    leddev.led0_gpio = of_get_named_gpio(leddev.nd, "led-gpio", 0);
133
    if (leddev.led0_gpio < 0){
134
        printk("unable find gpio\r\n");
135
        return -EINVAL;
136
    }
137

138
    gpio_request(leddev.led0_gpio, "led0");
139
    gpio_direction_output(leddev.led0_gpio, 1);
140

141
    return 0;
142
}
143

144
/* Platform驱动被移除时执行此函数 */
145
static int led_remove(struct platform_device *dev)
146
{
147
    gpio_set_value(leddev.led0_gpio, 1);
148

149
    cdev_del(&leddev.cdev);
150
    unregister_chrdev_region(leddev.devid, LEDDEV_CNT);
151
    device_destroy(leddev.class, leddev.devid);
152
    class_destroy(leddev.class);
153

154
    return 0;
155
}
156

157
/* Platform匹配设备树 */
158
static const struct of_device_id led_of_match[] = {
159
    {.compatible = "custom-gpioled"},
160
};
161

162
static struct platform_driver led_driver = {
163
    .driver = {
164
        .name = "imx6ul-led",
165
        .of_match_table = led_of_match,
166
    },
167
    .probe = led_probe,
168
    .remove = led_remove,
169
};
170

171
static int __init leddriver_init(void)
172
{
173
    return platform_driver_register(&led_driver);
174
}
175

176
static void __exit leddriver_exit(void)
177
{
178
    platform_driver_unregister(&led_driver);
179
}
180

181
module_init(leddriver_init);
182
module_exit(leddriver_exit);
183
MODULE_LICENSE("GPL");
184
MODULE_AUTHOR("aki");

应用程序#

1
#include "stdio.h"
2
#include "unistd.h"
3
#include "sys/types.h"
4
#include "sys/stat.h"
5
#include "fcntl.h"
6
#include "stdlib.h"
7
#include "string.h"
8
#include "errno.h"
9
#include "linux/ioctl.h"
10
#include "sys/select.h"
11
#include "sys/time.h"
12
#include "sys/poll.h"
13
#include "signal.h"
14

15
#define LEDOFF  0
16
#define LEDON   1
17

18
int main(int argc, char *argv[])
19
{
20
    int fd, ret;
21
    char *filename;
22
    unsigned char databuf[2];
23

24
    if (argc != 3){
25
        printf("error usage\r\n");
26

27
        return -1;
28
    }
29

30
    filename = argv[1];
31
    fd = open(filename, O_RDWR);
32
    if (fd < 0){
33
        printf("unable open file %s\r\n", argv[1]);
34
        return -1;
35
    }
36

37
    databuf[0] = atoi(argv[2]);
38
    ret = write(fd, databuf, sizeof(databuf));
39
    if (ret < 0){
40
        printf("LED control failed\r\n");
41
        close(fd);
42
        return -1;
43
    }
44

45
    ret = close(fd);
46
    if (ret < 0){
47
        printf("file %s unable close\r\n", filename);
48
        return -1;
49
    }
50

51
    return 0;
52
}

使用Linux原生LED驱动#

Linux原生支持了通过GPIO控制LED的驱动，位于/drivers/leds下。通常LED会作为系统运行指示灯（呼吸灯）或者硬盘工作指示灯进行工作。6.6.52版本Kernel下原生LED驱动支持默认是打开的，仅需要手动修改设备树。设备树的节点编写规则位于/Documentation/devicetree/bindings/leds/leds-gpio.txt。添加以下节点：

1
    dtsleds {   /* LED设备 */
2
      compatible = "gpio-leds";
3

4
      led0 {
5
        label = "red";  /* label属性，一般为LED灯的名字，用颜色区分 */
6
        gpios = <&gpio1 3 GPIO_ACTIVE_LOW>;
7
        default-state = "on";  /* 默认打开 */
8
                linux,default-trigger = "heartbeat";    /* 作为系统呼吸灯 */
9
      };
10
    };