Linux驱动入门（三）Led驱动

╰+哭是因爲堅強的太久メ 2021-10-30 07:42 508阅读 0赞

**Linux驱动入门系列**

[Linux驱动入门（一）字符设备驱动基础][Linux]

[Linux驱动入门（二）操作硬件][Linux 1]

[Linux驱动入门（三）Led驱动][Linux_Led]

[Linux驱动入门（四）非阻塞方式实现按键驱动][Linux 2]

[Linux驱动入门（五）阻塞方式实现按键驱动][Linux 3]

[Linux驱动入门（六）poll机制实现按键驱动][Linux_poll]

[Linux驱动入门（七）使用定时器消除按键抖动][Linux 4]

# Linux驱动入门（三）Led驱动 #

### 文章目录 ###

*  Linux驱动入门（三）Led驱动
 *   *  一、注册字符设备驱动
     *  二、操作硬件
     *   *  2.1 控制led
         *  2.2 通用方式实现
         *  2.3 gpiolib实现
     *  三、源码
     *   *  3.1 通用方式实现
         *  3.2 gpiolib实现
     *  四、测试

**目的**：实现一个led驱动，应用层写入1led亮，写0led灭

## 一、注册字符设备驱动 ##

led驱动是一个字符设备驱动，编写led驱动首先要注册字符设备，生成设备节点，然后再是完善文件操作集合

关于如何注册字符设备和生成设备字节，在[Linux驱动入门（一）字符设备驱动基础][Linux]中讲得比较详细了，这里给出代码

#include <linux/module.h>
    #include <linux/init.h>
    #include <linux/fs.h>
    #include <linux/cdev.h>
    #include <linux/slab.h>
    #include <linux/device.h>
    
    #include <asm/io.h>
    #include <asm/uaccess.h>
    
    static dev_t dev_id;
    static struct cdev *led_dev;
    static struct class *led_class;
    
    int led_open(struct inode *inode, struct file *file)
    {
        
    	/* 设置gpio */
        
        return 0;
    }
    
    ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
    {
        
    	int val, ret;
        
        /* 从用户空间拷贝数据 */
        ret = copy_from_user(&val, data, sizeof(val));
        
        if(val == 0)
        {
        
            /* 熄灭led */
        }
        else if(val == 1)
        {
        
            /* 点亮 */
        }
        
        return 0;
    }
    
    static struct file_operations led_fops = {
        
    	.owner = THIS_MODULE,
        .open   = led_open,
        .write  = led_write,
    };
    
    static __init int led_init(void)
    {
        
        /* 申请设备号 */
        alloc_chrdev_region(&dev_id, 1, 1, "led");
    
        /* 分配字符设备 */
        led_dev = cdev_alloc();
    
        /* 设置字符设备 */
        cdev_init(led_dev, &led_fops);
    
        /* 注册字符设备 */
        cdev_add(led_dev, dev_id, 1);
    
        /* 创建设备节点 */
    	led_class = class_create(THIS_MODULE, "led"); //创建类
    	device_create(led_class, NULL, dev_id, NULL, "led"); //创建设备节点
    
        return 0;
    }
    
    static __exit void led_exit(void)
    {
        
        /* 注销设备节点 */
        device_destroy(led_class, dev_id);
        class_destroy(led_class);
    
        /* 注销字符设备 */
        cdev_del(led_dev);
        kfree(led_dev);
    
        /* 注销注册的设备号 */
        unregister_chrdev_region(dev_id, 1);
    }
    
    module_init(led_init);
    module_exit(led_exit);
    
    MODULE_LICENSE("GPL");

编译上面的驱动程序，加载模块，就会生成`/dev/led`设备节点，这是我们led驱动的基本框架，我们还要在`led_open`、`led_write`中操作硬件

从上面代码中可以看到，在`led_open`中去设置gpio，在`led_write`中，如果写1就点亮led，写0就熄灭led

这里介绍一个知识点，用户空间和内核空间不能通过指针直接访问，必须使用内核提供的函数

从用户空间到内核空间使用

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

从内核空间到用户空间使用

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

此时还未涉及到操作硬件，下面来具体介绍如何在驱动程序中去操作led

## 二、操作硬件 ##

### 2.1 控制led ###

下面开始来介绍如何去操作led

首先打开开发板的原理图，找到led，如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70]

这里我要操作nLED1，发现其有GPJ0\_3引脚控制，当GPJ0\_3引脚高电平，led被点亮，当GPJ0\_3引脚为低电平，led被熄灭

下面查看芯片的datasheet，看如何控制GPJ0\_3引脚的高低电平

找到了两个相关的寄存器`GPJ0CON`和`GPJ0DAT`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][20190821170943747.PNG]

从图中可以看到`GPJ0CON`寄存器的地址为`0xE020_0240`，该寄存器32位有效，其中GPJ0CON\[3\]（12-15位）设置引脚的功能

`GPJ0DAT`寄存器的地址为`0xE0020_0244`，该寄存器8位有效，其中GPJ0DAT\[3\]（第3位）控制引脚的高低电平

那么想要设置引脚的高低电平可以这样做

GPJ0CON |= 1<<12; //配置GPJ0_3为输出状态
    
    GPJ0DAT |= 1<<3; //输出高电平
    GPJ0DAT &= ~(1<<3); //输出低电平

从而达到控制led亮灭的目的

在[Linux驱动入门（二）操作硬件][Linux 1]中详细地讲解了如何去操作硬件，分别有通用方法和使用gpiolib的方法，下面将介绍这两种方法

### 2.2 通用方式实现 ###

使用通用的方法来设置gpio高低电平

首先找到寄存器的物理地址

#define GPJ0CON_PHY_ADDR 0xE0200240
    #define GPJ0DAT_PHY_ADDR 0xE0200244

然后映射物理地址

static volatile unsigned int *gpj0_con = NULL;
    static volatile unsigned int *gpj0_dat = NULL;
    
    gpj0_con = (volatile unsigned int *)ioremap(GPJ0CON_PHY_ADDR, 8);
    gpj0_dat = gpj0_con+1;

配置引脚的功能

unsigned int cfg;
    
    /* 将GPIO设置为输出模式 */
    cfg = readl(gpj0_con);
    writel(cfg | (1<<12), gpj0_con);

设置引脚高低电平

/* 高电平 */
    cfg = readl(gpj0_dat);
    writel(cfg | (1<<3), gpj0_dat);
    
    /* 低电平 */
    cfg = readl(gpj0_dat);
    writel(cfg & ~(1<<3), gpj0_dat);

取消地址映射

iounmap(gpj0_con);

稍后将给出驱动源码

### 2.3 gpiolib实现 ###

使用gpiolib可以不用直接操作寄存器，这就变得非常简单了

申请gpio

gpio_request(S5PV210_GPJ0(3), "led");

设置gpio为输出模式

gpio_direction_output(S5PV210_GPJ0(3), 1);

设置gpio的高低电平

gpio_set_value(S5PV210_GPJ0(3), 1); //高电平
    gpio_set_value(S5PV210_GPJ0(3), 0); //低电平

## 三、源码 ##

### 3.1 通用方式实现 ###

#include <linux/module.h>
    #include <linux/init.h>
    #include <linux/fs.h>
    #include <linux/cdev.h>
    #include <linux/slab.h>
    #include <linux/device.h>
    
    #include <asm/io.h>
    #include <asm/uaccess.h>
    
    #define GPJ0CON_PHY_ADDR 0xE0200240
    #define GPJ0DAT_PHY_ADDR 0xE0200244
    
    static dev_t dev_id;
    static struct cdev *led_dev;
    static struct class *led_class;
    
    static volatile unsigned int *gpj0_con = NULL;
    static volatile unsigned int *gpj0_dat = NULL;
    
    int led_open(struct inode *inode, struct file *file)
    {
        
        unsigned int cfg;
    
        /* 将GPIO设置为输出模式 */
        cfg = readl(gpj0_con);
        writel(cfg | (1<<12), gpj0_con);
    
        /* 熄灭led */
        cfg = readl(gpj0_dat);
        writel(cfg | (1<<3), gpj0_dat);
    
        return 0;
    }
    
    ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
    {
        
        int val, ret;
        unsigned int cfg;
    
        /* 从用户空间拷贝数据 */
        ret = copy_from_user(&val, data, sizeof(val));
    
        cfg = readl(gpj0_dat);
    
        if(val == 0) //熄灭
        {
        
            writel(cfg | (1<<3), gpj0_dat);
        }
        else if(val == 1) //点亮
        {
        
            writel(cfg & ~(1<<3), gpj0_dat);
        }
        else
            return -1;
    
        return 0;
    }
    
    static struct file_operations led_fops = {
        
    	.owner = THIS_MODULE,
        .open   = led_open,
        .write  = led_write,
    };
    
    static __init int led_init(void)
    {
        
        /* 申请设备号 */
        alloc_chrdev_region(&dev_id, 1, 1, "led");
    
        /* 分配字符设备 */
        led_dev = cdev_alloc();
    
        /* 设置字符设备 */
        cdev_init(led_dev, &led_fops);
    
        /* 注册字符设备 */
        cdev_add(led_dev, dev_id, 1);
    
        /* 创建设备节点 */
    	led_class = class_create(THIS_MODULE, "led"); //创建类
    	device_create(led_class, NULL, dev_id, NULL, "led"); //创建设备节点
    
        /* 映射物理地址 */
        gpj0_con = (volatile unsigned int *)ioremap(GPJ0CON_PHY_ADDR, 8);
        gpj0_dat = gpj0_con+1;
    
        return 0;
    }
    
    static __exit void led_exit(void)
    {
        
        /* 注销设备节点 */
        device_destroy(led_class, dev_id);
        class_destroy(led_class);
    
        /* 注销字符设备 */
        cdev_del(led_dev);
        kfree(led_dev);
    
        /* 注销注册的设备号 */
        unregister_chrdev_region(dev_id, 1);
    
        /* 注销映射的地址 */
        iounmap(gpj0_con);
    }
    
    module_init(led_init);
    module_exit(led_exit);
    
    MODULE_LICENSE("GPL");

### 3.2 gpiolib实现 ###

#include <linux/module.h>
    #include <linux/init.h>
    #include <linux/fs.h>
    #include <linux/cdev.h>
    #include <linux/slab.h>
    #include <linux/device.h>
    #include <linux/gpio.h>
    
    #include <asm/io.h>
    #include <asm/uaccess.h>
    
    #include <mach/gpio.h>
    
    static dev_t dev_id;
    static struct cdev *led_dev;
    static struct class *led_class;
    
    int led_open(struct inode *inode, struct file *file)
    {
        
        gpio_direction_output(S5PV210_GPJ0(3), 1);
    
        return 0;
    }
    
    ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
    {
        
        int val, ret;
    
        /* 从用户空间拷贝数据 */
        ret = copy_from_user(&val, data, sizeof(val));
    
        if(val == 0) //熄灭
        {
        
            gpio_set_value(S5PV210_GPJ0(3), 1);
        }
        else if(val == 1) //点亮
        {
        
            gpio_set_value(S5PV210_GPJ0(3), 0);
        }
        else
            return -1;
    
        return 0;
    }
    
    static struct file_operations led_fops = {
        
    	.owner = THIS_MODULE,
        .open   = led_open,
        .write  = led_write,
    };
    
    static __init int led_init(void)
    {
        
        /* 申请设备号 */
        alloc_chrdev_region(&dev_id, 1, 1, "led");
    
        /* 分配字符设备 */
        led_dev = cdev_alloc();
    
        /* 设置字符设备 */
        cdev_init(led_dev, &led_fops);
    
        /* 注册字符设备 */
        cdev_add(led_dev, dev_id, 1);
    
        /* 创建设备节点 */
    	led_class = class_create(THIS_MODULE, "led"); //创建类
    	device_create(led_class, NULL, dev_id, NULL, "led"); //创建设备节点
    
        /* 申请gpio */
        gpio_request(S5PV210_GPJ0(3), "led");
    
        return 0;
    }
    
    static __exit void led_exit(void)
    {
        
        /* 注销设备节点 */
        device_destroy(led_class, dev_id);
        class_destroy(led_class);
    
        /* 注销字符设备 */
        cdev_del(led_dev);
        kfree(led_dev);
    
        /* 注销注册的设备号 */
        unregister_chrdev_region(dev_id, 1);
    
        gpio_free(S5PV210_GPJ0(3));
    }
    
    module_init(led_init);
    module_exit(led_exit);
    
    MODULE_LICENSE("GPL");

## 四、测试 ##

将上面两个驱动程序中任意一个保存为`led_drv.c`

下面是一个Makefile

KERN_DIR = /work/linux/kernel
    
    all:
            make -C $(KERN_DIR) M=`pwd` modules
    
    clean:
            make -C $(KERN_DIR) M=`pwd` modules clean
            rm -rf modules.order
    
    obj-m   += led_drv.o

修改你的内核源码树，执行make，生成led\_drv.ko，通过`insmod led_drv.ko`加载模块

此时将生成`/dev/led`的设备节点

**测试应用程序**

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <string.h>
    
    #define LED_DEV "/dev/led"
    
    int main(int argc, char* argv[])
    {
        
        int val;
        int fd;
    
        if(argc != 2)
        {
        
            printf("Usage: %s <on|off>\n", argv[0]);
            return -1;
        }
    
        fd = open(LED_DEV, O_RDWR);
        if(fd < 0)
        {
        
            printf("failed to open %s\n", LED_DEV);
            return -1;
        }
    
        if(!strcmp(argv[1], "on"))
            val = 1;
        else if(!strcmp(argv[1], "off"))
            val = 0;
        else
        {
        
            printf("Usage: %s <on|off>\n", argv[0]);
            return -1;
        }
    
        write(fd, &val, sizeof(val));
    
        close(fd);
    
        return 0;
    }

将此应用程序保存为`led_test.c`，编译`arm-linux-gcc -o led_test led_test.c`

执行`led_test on`，led被点亮

执行`led_test off`，led被熄灭

[Linux]: https://blog.csdn.net/weixin_42462202/article/details/99887783
[Linux 1]: https://blog.csdn.net/weixin_42462202/article/details/99949396
[Linux_Led]: https://blog.csdn.net/weixin_42462202/article/details/99979562
[Linux 2]: https://blog.csdn.net/weixin_42462202/article/details/99998992
[Linux 3]: https://blog.csdn.net/weixin_42462202/article/details/100011481
[Linux_poll]: https://blog.csdn.net/weixin_42462202/article/details/100017339
[Linux 4]: https://blog.csdn.net/weixin_42462202/article/details/100019418
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70]: /images/20211029/8d6185976dd74255ba077d9c03c9d4ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70 1]: /images/20211029/c0f98e39b7854580b30668e481550bc3.png
[20190821170943747.PNG]: /images/20211029/4f968f9ff4b442a48b1561f2837b7f8c.png