2、点亮LED

本文转载自查看原文 2019-05-09 18:22 724 字符设备驱动/ TINY4412/ Linux驱动/ 驱动系列

接着上一章，本章来实现控制LED的亮灭操作：

一、驱动框架

#include <linux/fs.h>
#include <linux/init.h>

/* 定义文件内私有结构体 */
struct led_device {
    struct cdev cdev;
    int stat;            /* 用于保存LED状态，0为灭，1为亮 */
};

/* LED write()函数 */
static ssize_t led_write(struct file *filep, const char __user * buf, size_t len, loff_t *ppos)
{
    return 0;
}

/* LED open()函数 */
static int led_open(struct inode *inodep, struct file *filep)
{
    return 0;
}

/* 把定义的函数接口集合起来，方便系统调用 */
static const struct file_operations led_fops = {
    .open  = led_open,
    .write = led_write,
};

/* 驱动初始化函数 */
static int __init led_init(void)
{
    return 0;
}
 
/* 驱动卸载函数 */
static void __exit led_exit(void)
{
}
 
/* 声明段属性 */
module_init(led_init);
module_exit(led_exit);

MODULE_LICENSE("GPL");

我们在驱动程序实现的write()和open()函数的格式必须遵循struct file_operations里面的函数指针：

struct file_operations {
    struct module *owner;
    loff_t (*llseek) (struct file *, loff_t, int);
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    int (*readdir) (struct file *, void *, filldir_t);
    unsigned int (*poll) (struct file *, struct poll_table_struct *);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    int (*mmap) (struct file *, struct vm_area_struct *);
    int (*open) (struct inode *, struct file *);
    int (*flush) (struct file *, fl_owner_t id);
    int (*release) (struct inode *, struct file *);
...
};

通常我们不会实现struct file_operations里面的所有函数，只会实现一些针对某些设备需要用到的函数

驱动中定义的led_init()和led_exit()函数需要实现向上层注册字符设备、struct file_operations等

这两个函数所使用到的__init和__exit，在此以__init为例展开：

#define __init            __attribute__((".init.text")) \
                        __attribute__((__cold__)) \
                        __attribute__((no_instrument_function))

可以看到led_init()函数代码会被定位到.init.text段中

这个段定义在include/asm-generic/vmlinux.lds.h中

#define INIT_TEXT_SECTION(inittext_align)                \
    . = ALIGN(inittext_align);                    \
    .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {        \
        VMLINUX_SYMBOL(_sinittext) = .;                \
        INIT_TEXT                        \
        VMLINUX_SYMBOL(_einittext) = .;                \
    }

在arch/arm/kernel/vmlinux.lds.S中使用

    INIT_TEXT_SECTION(8)

驱动程序中调用的module_init()和module_exit()函数用于向上层注册led_init()和led_exit()

#define module_init(x)            __initcall(x)
#define __initcall(fn)            device_initcall(fn)

...

#define core_initcall(fn)        __define_initcall("1",fn,1)
#define core_initcall_sync(fn)        __define_initcall("1s",fn,1s)
#define postcore_initcall(fn)        __define_initcall("2",fn,2)
#define postcore_initcall_sync(fn)    __define_initcall("2s",fn,2s)
#define arch_initcall(fn)        __define_initcall("3",fn,3)
#define arch_initcall_sync(fn)        __define_initcall("3s",fn,3s)
#define subsys_initcall(fn)        __define_initcall("4",fn,4)
#define subsys_initcall_sync(fn)    __define_initcall("4s",fn,4s)
#define fs_initcall(fn)            __define_initcall("5",fn,5)
#define fs_initcall_sync(fn)        __define_initcall("5s",fn,5s)
#define rootfs_initcall(fn)        __define_initcall("rootfs",fn,rootfs)
#define device_initcall(fn)        __define_initcall("6",fn,6)
#define device_initcall_sync(fn)    __define_initcall("6s",fn,6s)
#define late_initcall(fn)        __define_initcall("7",fn,7)
#define late_initcall_sync(fn)        __define_initcall("7s",fn,7s)

...

#define __define_initcall(fn, id) \
    static initcall_t __initcall_##fn##id __used \
    __attribute__((__section__(".initcall" #id ".init"))) = fn; \
    LTO_REFERENCE_INITCALL(__initcall_##fn##id)

最终，led_init()函数的地址会被定位到.initcall6.init段中

那么initcall为什么要分成这么多段呢？

系统的初始化时，所有的东西都必须按照一定的顺序初始化

对于驱动注册，是在上面的initcall6里面实现的。而要实现设备驱动的注册，必须要在设备驱动模型初始化完之后才能进行，否则如果设备驱动的管理程序都还没初始化，则驱动的注册肯定就有问题了。而要想让初始化阶段先初始化驱动的管理程序，如果靠函数依次调用，因为内核的内容太庞大，这明显不可能实现。所以初始化阶段，内核按先后顺序分了16个子阶段阶段

通常越靠前的是越底层越核心的初始化，通常后面的初始化对前面的都有一定的依赖

总结起来就是：

1. __init修饰的函数，表示把该函数放入init.text这个代码段

2. module_init修饰的函数，表示把init.text代码段中的函数地址，存到init.data段

3. 内核启动时，会根据initcall后面的数字大小，分层进行调用初始化

驱动程序中的MODULE_LICENSE("GPL");用于表示许可证，不需要深度了解

现在我们在框架的基础上完成注册字符设备、struct file_operations等操作

二、完成init()函数和exit()函数

 1 ...
 2 
 3 static int g_major;
 4 module_param(g_major, int, S_IRUGO);
 5 
 6 static struct led_device*    dev;
 7 static struct class*        scls;
 8 static struct device*        sdev;
 9 
10 ...
11 
12 static int __init led_init(void)
13 {
14     int ret;
15     dev_t devt;
16 
17     /* 1. 申请设备号 */
18     if (g_major) {
19         devt = MKDEV(g_major, 0);
20         ret = register_chrdev_region(devt, 1, "led");
21     }
22     else
23         ret = alloc_chrdev_region(&devt, 0, 1, "led");
24     if (ret)
25         return ret;
26 
27     /* 2. 申请文件内私有结构体 */
28     dev = kzalloc(sizeof(struct led_device), GFP_KERNEL);
29     if (dev == NULL) {
30         ret = -ENOMEM;
31         goto fail_malloc;
32     }
33 
34     /* 3. 注册字符设备驱动 */
35     cdev_init(&dev->cdev, &led_fops);    /* 初始化cdev并链接file_operations和cdev */
36     ret = cdev_add(&dev->cdev, devt, 1);    /* 注册cdev */
37     if (ret)
38         return ret;
39 
40     /* 4. 创建类设备，insmod后会生成/dev/led设备文件 */
41     scls = class_create(THIS_MODULE, "led");
42     sdev = device_create(scls, NULL, devt, NULL, "led");
43 
44     return 0;
45 
46 fail_malloc:
47     unregister_chrdev_region(devt, 1);
48 
49     return ret;
50 }
51 
52 static void __exit led_exit(void)
53 {
54     /* 镜像注销 */
55     dev_t devt = MKDEV(g_major, 0);
56 
57     device_destroy(scls, devt);
58     class_destroy(scls);
59 
60     cdev_del(&(dev->cdev));
61     kfree(dev);
62 
63     unregister_chrdev_region(devt, 1);
64 }
65 
66 ...

代码中第4行：module_param(g_major, int, S_IRUGO)表示int型变量g_major可以通过外部向内核传递值

S_IRUGO表示数值的权限为0444

函数原型如下，此函数用于在加载模块时或者模块加载以后传递参数给模块

module_param(name,type,perm);

函数参数：

name：模块参数的名称

type：模块参数的数据类型，如bool、charp（字符指针）、short、int、long、ulong（无符号long）

perm：模块参数的访问权限

代码中第15行：dev_t devt定义了设备号，为32位，其中高12位为主设备号，低20位为次设备号

主设备号用来表示一个特定的驱动程序；次设备号用来表示使用该驱动程序的各设备。例如TINY4412，有4个LED，每个LED都可以独立的打开或者关闭。那么，这个LED的字符设备驱动程序，可以将其主设备号注册成5号设备，次设备号分别为1、2、3和4。这里，次设备号就分别对应4个LED

设备文件通常都在/dev目录下：

如上图的/dev/tty，它的主设备号是5，次设备号是0

使用以下宏可以从dev_t中获取主设备号和次设备号：

MAJOR(dev_t dev)
MINOR(dev_t dev)

使用以下宏则可以通过主设备号和次设备号生成dev_t：

MKDEV(int major, int minor)

代码中第20行和第23行：register_chrdev_region()和alloc_chrdev_region()用于向系统申请设备号，这两个函数原型为：

int register_chrdev_region(dev_t from, unsigned count, const char *name)

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
            const char *name)

函数参数：

from：要分配的设备号范围的初始值，其中的次设备号通常设置为0

count：连续编号设备个数

name：设备名称

dev：alloc_chrdev_region()返回的设备号

baseminor：次设备号起始值，通常设置为0

register_chrdev_region()函数用于已知起始设备的设备号情况；而alloc_chrdev_region()函数用于设备号未知的情况，由系统分配并返回分配对的设备号

释放设备号函数原型为：

void unregister_chrdev_region(dev_t from, unsigned count)

代码中第28行：kzalloc()用于申请一片内核内存，并清空内存数据，详细了解可查看：Linux驱动函数解读第一节

Linux内核提供了一组函数操作cdev结构体：

cdev_init()用于初始化cdev的成员，并建立cdev和file_operations之间的链接

cdev_alloc()用于动态申请一个cdev内存，本节代码使用的申请内存函数为kzalloc()

cdev_add()函数和cdev_del()函数分别向系统添加和删除一个cdev，完成字符设备的注册和注销

代码中第7行：struct class用于表示一个类，类是一个设备的高层视图，它抽象出了低层的实现细节，大概意思就是抽象出了一个通用的接口，类似于C++的面向对象的编程方式

代码中第8行：struct device用于表示一个设备，关于device的注册过程可以查看Linux驱动函数解读第二节

我们可以把类当作一个班级，设备当作学生。班级用于容纳学生，当老师来上课时，老师只需要讲一遍，学生就都可以听到（函数抽象）

三、完成write()函数、open()函数和release()函数

 1 static volatile unsigned long *gpm4con;
 2 static volatile unsigned long *gpm4dat;
 3 
 4 /* LED write()函数 */
 5 static ssize_t led_write(struct file *filep, const char __user * buf, size_t len, loff_t *ppos)
 6 {
 7     struct led_device *dev = filep->private_data;
 8 
 9     if (copy_from_user(&(dev->stat), buf, 1))
10         return -EFAULT;
11 
12     if (dev->stat == 1)
13         *gpm4dat &= ~((1 << 3) | (1 << 2) | 1);
14     else
15         *gpm4dat |= ((1 << 3) | (1 << 2) | 1);
16 
17     return 1;
18 }
19 
20 /* LED open()函数 */
21 static int led_open(struct inode *inodep, struct file *filep)
22 {
23     struct led_device *dev;
24 
25     dev = container_of(inodep->i_cdev, struct led_device, cdev);
26     // 放入私有数据中
27     filep->private_data = dev;
28 
29     // 映射LED
30     gpm4con = ioremap(0x110002E0, 8);
31     gpm4dat = gpm4con + 1;
32     // 设为输入引脚，灭灯
33     *gpm4con = 0x1111;
34     *gpm4dat |= ((1 << 3) | (1 << 2) | 1);
35 
36     return 0;
37 }
38 
39 static int led_close(struct inode *inodep, struct file *filep)
40 {
41     iounmap(gpm4con);
42     
43     return 0;
44 }
45 
46 /* 把定义的函数接口集合起来，方便系统调用 */
47 static const struct file_operations led_fops = {
48     .owner = THIS_MODULE,
49     .write = led_write,
50     .open  = led_open,
51     .release = led_close,
52 };

代码中第5行：write()函数使用了文件私有数据（filp->private_data）。实际上，大多数Linux驱动遵循一个“潜规则”，那就是将文件的私有数据private_data指向设备结构体，再用read()、write()等函数通过private_data访问设备结构体

需要注意的是，用户空间不能直接访问内核空间的内存，因此在read()函数中一般使用copy_to_user()，在write()函数中一般使用copy_from_user()来完成用户空间和内核空间的数据复制，两函数原型为：

unsigned long copy_from_user(void *to, const void __user *from, unsigned long n)

unsigned long copy_to_user(void __user *to, const void *from, unsigned long n)

函数参数以及返回值：

to：复制到的地址

from：待复制的地址

n：复制字节数

返回值：两函数均不返回被复制的字节数，成功返回0，失败返回负值

代码中第25行：container_of()函数可以参考：Linux驱动函数解读第三节

在Linux系统中，开启MMU后，我们就不能直接使用寄存器的硬件地址（或者说我们不知道，寄存器硬件地址被映射到哪块内存了），所以我们只能使用虚拟地址来操纵寄存器。而目前我们不知道虚拟地址，只知道物理地址

所以内核给我们提供了一个接口函数ioremap()。它会建立一个新的页表，可以通过寄存器的物理地址得到寄存器的虚拟地址。

void __iomem *ioremap(phys_addr_t offset, unsigned long size)

函数参数以及返回值：

offset：物理地址

size：寄存器大小

返回值：成功返回虚拟地址，失败返回-1

ioremap()函数对应的释放函数为iounmap()：

void iounmap(void __iomem *addr)

函数参数：

addr：ioremap()函数返回的虚拟地址

四、完整代码

led源代码：

  1 #include <linux/module.h>
  2 #include <linux/fs.h>
  3 #include <linux/init.h>
  4 #include <linux/cdev.h>
  5 #include <linux/slab.h>
  6 #include <linux/device.h>
  7 
  8 #include <asm/uaccess.h>
  9 #include <asm/io.h>
 10 
 11 /* 定义文件内私有结构体 */
 12 struct led_device {
 13     struct cdev cdev;
 14     int stat;            /* 用于保存LED状态，0为灭，1为亮 */
 15 };
 16 
 17 static int g_major;
 18 module_param(g_major, int, S_IRUGO);
 19 
 20 static struct led_device*    dev;
 21 static struct class*        scls;
 22 static struct device*        sdev;
 23 
 24 static volatile unsigned long *gpm4con;
 25 static volatile unsigned long *gpm4dat;
 26 
 27 /* LED write()函数 */
 28 static ssize_t led_write(struct file *filep, const char __user * buf, size_t len, loff_t *ppos)
 29 {
 30     struct led_device *dev = filep->private_data;
 31 
 32     if (copy_from_user(&(dev->stat), buf, 1))
 33         return -EFAULT;
 34 
 35     if (dev->stat == 1)
 36         *gpm4dat &= ~((1 << 3) | (1 << 2) | 1);
 37     else
 38         *gpm4dat |= ((1 << 3) | (1 << 2) | 1);
 39 
 40     return 1;
 41 }
 42 
 43 /* LED open()函数 */
 44 static int led_open(struct inode *inodep, struct file *filep)
 45 {
 46     struct led_device *dev;
 47 
 48     dev = container_of(inodep->i_cdev, struct led_device, cdev);
 49     // 放入私有数据中
 50     filep->private_data = dev;
 51 
 52     // 映射LED
 53     gpm4con = ioremap(0x110002E0, 8);
 54     gpm4dat = gpm4con + 1;
 55     // 设为输出引脚，灭灯
 56     *gpm4con = 0x1111;
 57     *gpm4dat |= ((1 << 3) | (1 << 2) | 1);
 58 
 59     return 0;
 60 }
 61 
 62 static int led_close(struct inode *inodep, struct file *filep)
 63 {
 64     iounmap(gpm4con);
 65     
 66     return 0;
 67 }
 68 
 69 /* 把定义的函数接口集合起来，方便系统调用 */
 70 static const struct file_operations led_fops = {
 71     .write = led_write,
 72     .open  = led_open,
 73     .release = led_close,
 74 };
 75 
 76 static int __init led_init(void)
 77 {
 78     int ret;
 79     dev_t devt;
 80 
 81     /* 1. 申请设备号 */
 82     if (g_major) {
 83         devt = MKDEV(g_major, 0);
 84         ret = register_chrdev_region(devt, 1, "led");
 85     }
 86     else {
 87         ret = alloc_chrdev_region(&devt, 0, 1, "led");
 88         g_major = MAJOR(devt);
 89     }
 90     if (ret)
 91         return ret;
 92 
 93     /* 2. 申请文件内私有结构体 */
 94     dev = kzalloc(sizeof(struct led_device), GFP_KERNEL);
 95     if (dev == NULL) {
 96         ret = -ENOMEM;
 97         goto fail_malloc;
 98     }
 99 
100     /* 3. 注册字符设备驱动 */
101     cdev_init(&dev->cdev, &led_fops);    /* 初始化cdev并链接file_operations和cdev */
102     ret = cdev_add(&dev->cdev, devt, 1);    /* 注册cdev */
103     if (ret)
104         return ret;
105 
106     /* 4. 创建类设备，insmod后会生成/dev/led设备文件 */
107     scls = class_create(THIS_MODULE, "led");
108     sdev = device_create(scls, NULL, devt, NULL, "led");
109 
110     return 0;
111 
112 fail_malloc:
113     unregister_chrdev_region(devt, 1);
114 
115     return ret;
116 }
117  
118 static void __exit led_exit(void)
119 {
120     /* 镜像注销 */
121     dev_t devt = MKDEV(g_major, 0);
122 
123     device_destroy(scls, devt);
124     class_destroy(scls);
125 
126     cdev_del(&(dev->cdev));
127     kfree(dev);
128 
129     unregister_chrdev_region(devt, 1);
130 }
131  
132 /* 声明段属性 */
133 module_init(led_init);
134 module_exit(led_exit);
135 
136 MODULE_LICENSE("GPL");

View Code

Makefile：

 1 KERN_DIR = /work/tiny4412/tools/linux-3.5
 2 
 3 all:
 4     make -C $(KERN_DIR) M=`pwd` modules 
 5 
 6 clean:
 7     make -C $(KERN_DIR) M=`pwd` modules clean
 8     rm -rf modules.order
 9 
10 obj-m    += led.o

View Code

测试文件：

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <sys/types.h>
 4 #include <sys/stat.h>
 5 #include <fcntl.h>
 6 #include <string.h>
 7 
 8 int main(int argc, char** argv)
 9 {
10     if (argc != 2) {
11         printf("Usage: \n");
12         printf("%s <on|off>\n", argv[0]);
13         return -1;
14     }
15 
16     int fd;
17     fd = open("/dev/led", O_RDWR);
18     if (fd < 0) {
19         printf("can't open /dev/led\n");
20         return -1;
21     }
22 
23     char stat;
24     if (0 == strcmp(argv[1], "off")) {
25         stat = 0;
26         write(fd, &stat, 1);
27     } else {
28         stat = 1;
29         write(fd, &stat, 1);        
30     }
31     close(fd);
32 
33     return 0;
34 }

View Code

需要注意的是，Makefile中的KERN_DIR = /work/tiny4412/tools/linux-3.5需要改成自己的linux内核路径。

执行make命令编译.ko驱动程序

执行arm-linux-gcc test.c -o test_led

将驱动程序和测试程序复制到文件系统中，完成后如下图：

启动开发板，执行：

[root @ lioker / ] #cd /my_driver/dong/01.led/

挂载模块insmod：

[root @ lioker 01.led ] #insmod led.ko

[root @ lioker 01.led ] #./test_led on

[root @ lioker 01.led ] #./test_led off

卸载模块rmmod：

[root @ lioker 01.led ] #rmmod led.ko

可看到对应现象

其实源代码中的读写寄存器方式并不是值得推荐的，内核给我们提供了封装好的函数，如：

1 #define readb(c)        ({ u8  __v = readb_relaxed(c); __iormb(); __v; })
2 #define readw(c)        ({ u16 __v = readw_relaxed(c); __iormb(); __v; })
3 #define readl(c)        ({ u32 __v = readl_relaxed(c); __iormb(); __v; })
4 
5 #define writeb(v,c)        ({ __iowmb(); writeb_relaxed(v,c); })
6 #define writew(v,c)        ({ __iowmb(); writew_relaxed(v,c); })
7 #define writel(v,c)        ({ __iowmb(); writel_relaxed(v,c); })

函数使用可查看Linux驱动函数解读第四节

下一章 3、中断分析以及按键中断

免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。

猜您在找 MicroPython （一）点亮我的Led zigbee学习之路(二)点亮LED LED灯C语言的点亮方式使用寄存器点亮LED GPIO输出—使用固件库点亮LED 51单片机基础学习（1）点亮一个LED灯 3.修改第一个程序来点亮LED 树莓派4b点亮led灯基本步骤 AVR单片机教程——随机点亮LED STM32点亮闪烁LED灯