【全志T113-S3_100ask】1-2. 点灯工程师 —— LED驱动(基于设备树篇)

前言

上一讲我们知道了基于寄存器的点灯方法，但是那个方法太麻烦了。而且还要翻手册找寄存器，实在差点意思，那么这一讲，我将会介绍基于设备树实现点灯的相关内容。

一、查看原理图

这里跟上一讲一样，找到我们需要控制的LED是接在哪个引脚上的，我的开发板是接PB4引脚。并且是低电平点亮，高电平熄灭。

二、pinctrl子系统

Linux 是一个庞大而完善的系统，尤其是驱动框架，像 GPIO 这种最基本的驱动其实已经提供了一套完整的框架， Linux 内核提供了 pinctrl 子系统用于GPIO 驱动。接下，具体介绍一下：

2.1 pinctrl子系统的介绍

Linux 驱动讲究驱动分离与分层， pinctrl 子系统就是驱动分离与分层思想下的产物。传统的配置 pin 的方式就是直接操作相应的寄存器，但是这种配置方式比较繁琐、而且容易出问题(比如 pin 功能冲突)。 pinctrl 子系统就是为了解决这个问题而引入的， pinctrl 子系统主要工作内容如下：
①、获取设备树中 pin 信息。
​②、根据获取到的 pin 信息来设置 pin 的复用功能
​③、根据获取到的 pin 信息来设置 pin 的电气特性，比如上/下拉、速度、驱动能力等。对于我们使用者来讲，只需要在设备树里面设置好某个 pin 的相关属性即可，其他的初始化工作均由 pinctrl 子系统来完成， pinctrl 子系统源码目录为 drivers/pinctrl。

2.2 pinctrl子系统的使用(修改设备树)

基于全志T113-S3，在设备树的.dtsi中使用pio结点来描述pinctrl子系统信息。pinctrl 设 备 树 绑 定 信 息 可 以 参 考 文 档：

内核根目录/Documentation/devicetree/bindings/pinctrl	

1. pio节点添加引脚信息

在我们写一个设备的驱动的时候，需要用到某些GPIO口，首先，先添加pinctrl节点(也是就是添加驱动设备所使用的PIN配置信息)。

pinctrl子系统是用一个节点来描述的，定义在.dtsi文件中。对于不同的板子，这个节点的名称不同，正点原子imux6ull是用iomuxc来描述这个pinctrl子系统的，而全志T113是用pio节点来描述pinctrl子系统的。因为我们点灯需要用到PB4引脚，所以我们就要在设备树.dts文件中的pio节点下进行这种形式的添加:

标签名: 自定义节点名 {
    allwinner,pins =  "PB4"		//用PB4引脚就写PB4对应原理图的PB4
};

我这里添加完是这样的：

2. 设备节点中使用pio

在pio节点中添加好我们要使用的引脚信息后，接下来，就是我们的设备节点。首先我们在设备树的根节点上创建一个led设备节点，然后添加属性，具体如下：

lsc_gpio_led{
		#address-cells = <1>;
		#size = <1>;
		status = "okay";
		compatible = "allwinner,sunxi-pinctrl-test";
		pinctrl-names = "default";
		pinctrl-0 = <&led_pin>;		//pinctrl-0 属性设置 LED 灯所使用的 PIN 对应的 pinctrl 节点。
		led-gpio = <&pio PB 4 GPIO_ACTIVE_HIGH>;		//led-gpio 属性指定了 LED 灯所使用的 GPIO，这里我们通过原理图可以知道要使用PB4，默认高电平（熄灭状态）		
	};

3. 检查 PIN 是否被其他外设使用

检查pio节点与根节点，有没有其他地方也是用到PB4引脚的，把它给注释掉（编译没过就是注释有问题，最好一行一行的注释）。否则会有问题，比如驱动程序中申请GPIO失败。

三、程序部分

3.1 使用新字符框架编写驱动程序

上一讲的驱动程序，使用的是相对旧的驱动框架，在挂载驱动后，还要我们手动创建字符设备，所以这一讲后，我们都会去使用新字符驱动框架去编写字符驱动程序。

1. 定义描述设备结构体

我们使用宏和结构体去描述整个设备：

#define GPIOLED_CNT 1		//设备数量，这里以单设备为例子
#define GPIOLED_NAME "设备名字"		//这个名字跟设备树的节点名一定要一样，内核靠这个来
struct XXX{
	int major;      //主设备号
       int minor;      //次设备号
       dev_t devid;           //设备号
       struct cdev cdev;       //字符设备
       struct class *class;        //类
       struct device *device;      //设备
       struct device_node *XXnode;		//指向设备树节点
};

2. 动态申请设备号

/* 注册字符设备 */
    XX_dev.major = 0;       //设备号由内核分配
    if(XX_dev.major)        //定义了设备号
    {
        XX_dev.devid = MKDEV(XX_dev.major,0);       
        ret = register_chrdev_region(XX_dev.devid, DTSLED_CNT, DTSLED_NAME);
    }
    else                    //没有给定设备号
    {
        ret = alloc_chrdev_region(&XX_dev.devid,0,DTSLED_CNT,DTSLED_NAME);
        XX_dev.major = MAJOR(XX_dev.devid);
        XX_dev.minor = MINOR(XX_dev.devid );
    }
    if(ret < 0)
    {
        printk("[failed] devid error!");
        goto fail_devid;
    }

3. 初始化cdev

/* 设备操作函数 */
static struct file_operations test_fops = {
    .owner = THIS_MODULE,
    .write = ,
    .open = ,
    .release = ,
    .read = ,
    ......
    /* 其他具体的初始项 */
};

XX_dev.cdev.owner = THIS_MODULE;
cdev_init(&XX_dev.cdev, &test_fops); /* 初始化 cdev 结构体变量 */
ret = cdev_add(&XX_dev.cdev, XX_dev.devid, 1); /* 添加字符设备 */
if(ret < 0)
{
   goto fail_cdev;
}

4. 创建class类

XX_dev.class = class_create (THIS_MODULE,DTSLED_NAME);      
if (IS_ERR(XX_dev.class)) {
	ret = PTR_ERR(XX_dev.class);
    goto fail_class;
}

5. 创建设备device

XX_dev.device = device_create(XX_dev.class, NULL, XX_dev.devid, NULL,DTSLED_NAME);
    if(IS_ERR(XX_dev.device)){	
		ret = PTR_ERR(XX_dev.device);
        goto fail_device;
    }

6. 错误处理

fail_device:
    class_destroy(XX_dev.class);       //删除class类
fail_class:
    cdev_del(&XX_dev.cdev);         //卸载字符设备    
fail_cdev:
    unregister_chrdev_region(XX_dev.devid,DTSLED_CNT);      //释放字符设备号
fail_devid:
    return ret;

3.2 编写led_drv.c驱动程序

在编写驱动程序之前，一定要修改设备树，编译生成新的镜像烧录到开发板。

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPIOLED_CNT 1
#define GPIOLED_NAME "lsc_gpio_led"

#define LEDON 1
#define LEDOFF 0

struct gpioled_dev{
    int major;      //主设备号
    int minor;      //次设备号
    dev_t devid;           //设备号
    struct cdev cdev;       //字符设备
    struct class *class;        //类
    struct device *device;      //设备
    struct device_node *lednode;        //指向设备树的节点
    int led_gpio;           //设备使用的gpio编号
};

struct gpioled_dev gpioled;     //表示一整个可操作设备

/*open*/
static int gpioled_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &gpioled;       //作为私有数据
    return 0;
}

/*gpioled_release*/
static int gpioled_release(struct inode *inode, struct file *filp)
{
    struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;

    return 0;
}

/*gpioled_write*/
static ssize_t gpioled_write(struct file *filp, const char __user *buf,size_t count,loff_t *ppos)
{
    struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
    int ret;
    unsigned char databuf[1];       //属于内核的空间
    ret = copy_from_user(databuf,buf,1);
    if(ret < 0)
    {
        return -EINVAL;
    }

    if(databuf[0] == LEDON)
    {
        gpio_set_value(dev->led_gpio,0);
    }
    else if(databuf[0] == LEDOFF)
    {
        gpio_set_value(dev->led_gpio,1);
    }

    return ret;
}

/*gpioled_read*/
static ssize_t gpioled_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt)   //这里我们不需要读
{
    struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
    return 0;
}


static struct file_operations gpioled_fops = {
    .owner = THIS_MODULE,
    .write = gpioled_write,
    .open = gpioled_open,
    .release = gpioled_release,
    .read = gpioled_read,
    /* 其他具体的初始项 */
};

/* 驱动出入口函数 */
static int __init led_init(void)
{
    int ret = 0;
    printk("加载模块...\n");
    /* 申请设备号 */
    gpioled.major = 0;
    if (gpioled.major) {		 				 /* 定义了主设备号 */
        gpioled.devid = MKDEV(gpioled.major, 0); 			 /* 大部分驱动次设备号都选择 0*/
        register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
    } 
    else { 							 /* 没有定义设备号 */
        alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME); 			/* 申请设备号 */
        
        /*下面可省略，因为后面用devid就可以*/
        gpioled.major = MAJOR(gpioled.devid); 				 /* 获取分配号的主设备号 */
        gpioled.minor = MINOR(gpioled.devid); 				 /* 获取分配号的次设备号 */
    }

    /* 初始化cdev */
    gpioled.cdev.owner = THIS_MODULE;       //一定要的东西

    cdev_init(&gpioled.cdev,&gpioled_fops);         
    ret = cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
    if(ret < 0)
    {
        goto fail_cdev;
    }

    /* 创建calss类 */
    gpioled.class = class_create (THIS_MODULE,GPIOLED_NAME);      
    if (IS_ERR(gpioled.class)) {
		ret = PTR_ERR(gpioled.class);
        goto fail_class;
	}

    /* 创建设备 */
    gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL,GPIOLED_NAME);
    if(IS_ERR(gpioled.device)){	
		ret = PTR_ERR(gpioled.device);
        goto fail_device;
    }

    /* 获取设备树节点 */
    gpioled.lednode = of_find_node_by_path("/lsc_gpio_led");
    if(gpioled.lednode == NULL)
    {
        ret = -EINVAL;
        goto fail_find_nd;
    }

    /* 获取GPIO */
    gpioled.led_gpio = of_get_named_gpio(gpioled.lednode,"led-gpio",0);
    if(gpioled.led_gpio < 0)
    {
        printk("[failed] 没有找到GPIO口");
        ret = -EINVAL;
        goto fail_find_nd;
    }
    else
    {
        printk("[success] GPIO OK\n");
    }
    printk("gpio = %d\n",gpioled.led_gpio);
    
    /* 申请GPIO */
    ret = gpio_request(gpioled.led_gpio,"led-gpio");
    if(ret)
    {
        printk("[failed] 申请GPIO错误\n");
        ret = -EINVAL;
        goto fail_find_nd;
    }

    /* 设置GPIO输出或输入 */
    ret = gpio_direction_output(gpioled.led_gpio, 1);       //设置为输出默认高电平
    if(ret)
    {
        goto fail_gpio_err;
    }

    gpio_set_value(gpioled.led_gpio,0);

    return 0;
fail_gpio_err:
    gpio_free(gpioled.led_gpio);
fail_find_nd:
    device_destroy(gpioled.class, gpioled.devid);       //删除设备节点
fail_device:
    class_destroy(gpioled.class);       //删除class类
fail_class:
    cdev_del(&gpioled.cdev);         //卸载字符设备
fail_cdev:
    unregister_chrdev_region(gpioled.devid,GPIOLED_CNT);      //释放字符设备号
    return ret;
}

static void __exit led_exit(void)
{
    
    cdev_del(&gpioled.cdev);         //卸载字符设备
    unregister_chrdev_region(gpioled.devid,GPIOLED_CNT);      //释放字符设备号

    device_destroy(gpioled.class, gpioled.devid);       //删除设备节点
    class_destroy(gpioled.class);       //删除class类

    /* 释放GPIO */
    gpio_free(gpioled.led_gpio);
}

/* 驱动出入口注册函数 */
module_init(led_init);
module_exit(led_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("LSC");

3.3 编写led_test.c测试程序

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(int argc,char *argv[])
{
    int fd;
    int ret;
    unsigned char databuf[1];       //用户空间的数据缓冲区

    if(argc != 2)
    {
        printf("参数错误!\n");
        return -1;
    }

    fd = open("/dev/lsc_gpio_led",O_RDWR);
    if(fd == -1)
    {
        perror("open /dev/lsc_gpio_led [faild]");
        return -1;
    }

    if((strcmp(argv[1],"ON") == 0))
    {
        databuf[0] = 1;
    }
    else if((strcmp(argv[1],"OFF") == 0))
    {
        databuf[0] = 0;
    }

    ret = write(fd,databuf,1);
    if(ret < 0)
    {
        perror("灯操作发生错误!\n");
        return -1;
    }

    close(fd);
    return 0;
}

3.4 编写Makefile

KERNELDIR := /home/lsc666/tools/buildroot-100ask_t113-pro/buildroot/output/build/linux-origin_master

CURRENT_PATH := $(shell pwd)


build: kernel_modules
kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
	/home/lsc666/tools/buildroot-100ask_t113-pro/buildroot/output/host/bin/arm-linux-gnueabi-gcc led_test.c -o main
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
	
obj-m := led_drv.o

四、测试部分

把编译生成的led_drv.ko文件和main文件传到开发板中。
命令行执行如下命令：

insmod led_drv.ko		//挂载驱动
chmod 777 main			//可执行程序添加运行权限
./main ON				//点亮LED
./main OFF				//灭掉LED
rmmod led_drv.ko		//卸载驱动

五、最后

至此，点灯任务到此结束。下一讲会是什么呢？我也不知道。