pinctrl和gpio子系统

一、pinctrl子系统简介

Linux驱动讲究驱动分离与分层，pinctrl和gpio子系统就是驱动分离与分层思想下的产物，pinctrl子系统主要工作内容如下：

1. 获取设备树中的pin信息

1. 根据获取到的pin信息来设置pin的复用功能

1. 根据获取到的pin信息来设置pin的电气属性，比如上下拉、速度、驱动能力等

引脚的宏定义在imx6u-pinfunc.h这个头文件

设备树中添加pinctrl节点模板

1、创建对应的节点

同一个外设的pin都放到一个节点里面，打开imx6ull-alientek-emmc.dts，在iomuxc下面添加pinctrl_gpio_leds节点，添加完成后

pinctrl_gpio_leds: gpio-leds {
            fsl,pins = <
                MX6UL_PAD_GPIO1_IO03__GPIO1_IO03    0x17059
            >;
};

其中fsl.pins是固定属性，里面写的是设备所使用的PIN配置信息

二、gpio子系统

设置好设备树以后就可以使用gpio子系统提供的API函数来操作指定的GPIO，gpio子系统向驱动开发人员屏蔽了具体的读写寄存器过程。gpio子系统常用的API函数有下面几个：

1、gpio_request函数

gpio_request 函数用于申请一个 GPIO 管脚，在使用一个 GPIO 之前一定要使用 gpio_request

进行申请，函数原型如下：

int gpio_request(unsigned gpio, const char *label)

函数参数和返回值含义如下：

gpio：要申请的 gpio 标号，使用 of_get_named_gpio 函数从设备树获取指定 GPIO 属性信

息，此函数会返回这个 GPIO 的标号。

label：给 gpio 设置个名字。

返回值：0，申请成功；其他值，申请失败。

2、gpio_free函数

如果不使用某个 GPIO 了，那么就可以调用 gpio_free 函数进行释放。函数原型如下：

void gpio_free(unsigned gpio)

函数参数和返回值含义如下：

gpio：要释放的 gpio 标号。

返回值：无。

3、gpio_direction_input函数

此函数用于设置某个 GPIO 为输入，函数原型如下所示：

int gpio_direction_input(unsigned gpio)

4、gpio_direction_output函数

此函数用于设置某个 GPIO 为输出，并且设置默认输出值，函数原型如下：

int gpio_direction_output(unsigned gpio, int value)

函数参数和返回值含义如下：

gpio：要设置为输出的 GPIO 标号。

value：GPIO 默认输出值。

返回值：0，设置成功；负值，设置失败

5、gpio_get_value函数

此函数用于获取某个 GPIO 的值(0 或 1)，此函数是个宏，定义所示：

#define gpio_get_value __gpio_get_value
int __gpio_get_value(unsigned gpio)

函数参数和返回值含义如下：

gpio：要获取的 GPIO 标号。

返回值：非负值，得到的 GPIO 值；负值，获取失败。

6、gpio_set_value函数

此函数用于设置某个 GPIO 的值，此函数是个宏，定义如下

#define gpio_set_value __gpio_set_value
void __gpio_set_value(unsigned gpio, int value)

函数参数和返回值含义如下：

gpio：要设置的 GPIO 标号。

value：要设置的值。

添加LED设备节点

在个别节点“/”下创建LED灯节点，节点名是leds，节点内容如下：

leds {
        compatible = "gpio-leds";
        pinctrl-names = "default";
        pinctrl-0 = <&pinctrl_gpio_leds>;

        led1{
            label = "sys-led";
            gpios = <&gpio1 3 GPIO_ACTIVE_LOW>;
            linux,default-trigger = "heartbeat";
            default-state = "on";
        };
    };

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

检查PIN有没有被其他外设使用包括两个方面

1、检查pinctrl设置

2、如果这个PIN配置为GPIO的话，检查这个GPIO有没有被别的外设使用

在本章实验中 LED 灯使用的 PIN 为 GPIO1_IO03，因此先检查 GPIO_IO03 这个 PIN 有没有被其他的 pinctrl 节点使用，在 imx6ull-alientek-emmc.dts 中找到如下内容：

pinctrl_tsc: tscgrp {
            fsl,pins = <
                MX6UL_PAD_GPIO1_IO01__GPIO1_IO01    0xb0
                MX6UL_PAD_GPIO1_IO02__GPIO1_IO02    0xb0
                MX6UL_PAD_GPIO1_IO03__GPIO1_IO03    0xb0
                MX6UL_PAD_GPIO1_IO04__GPIO1_IO04    0xb0
            >;
};

pinctrl_tsc 节点是 TSC(电阻触摸屏接口)的 pinctrl 节点，从第 5行可以看出，默认情况下

GPIO1_IO03 作为了 TSC 外设的 PIN。所以我们需要将第 5 行屏蔽掉！

因为本章实验我们将 GPIO1_IO03 这个 PIN 配置为了 GPIO，所以还需要查找一下有没有其他的外设使用了 GPIO1_IO03，在 imx6ull-alientek-emmc.dts 中搜索“gpio1 3”，找到如下内容：

&tsc {
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_tsc>;
    xnur-gpio = <&gpio1 3 GPIO_ACTIVE_LOW>;
    measure-delay-time = <0xffff>;
    pre-charge-time = <0xfff>;
    status = "disabled";
};

tsc 是 TSC 的外设节点，从 4行可以看出，tsc 外设也使用了 GPIO1_IO03，同样我们需要将这一行屏蔽掉。然后在继续搜索“gpio1 3”，看看除了本章的 LED 灯以外还有没有其他的地方也使用了 GPIO1_IO03，找到一个屏蔽一个

设备树编写完成以后使用“make dtbs”命令重新编译设备树，然后使用新编译出来的imx6ull-alientek-emmc.dtb 文件启动 Linux 系统。启动成功以后进入“/proc/device-tree”目录中查看“gpioled”节点是否存在，如果存在的话就说明设备树基本修改成功

三、LED灯驱动程序编写

创建工程，工作区命名为DTSLED，工程创建好以后新建dtsled.c文件，输入内容

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>

#define DTSLED_CNT 1            /* 设备号个数 */
#define DTSLED_NAME "dtsled"    /* 名字 */
#define LEDON 1
#define LEDOFF 0

static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

struct dtsled_dev{
   dev_t devid;                    //设备号                  
   struct cdev cdev;                //cdev     
   struct cdev *class;              //类
   struct device *device;           //设备
   int major;
   int minor;
   struct device_node *nd;
};

struct dtsled_dev dtsled;

static void led_switch(u8 sta)
{
    u32 val = 0;
    if(sta == LEDON){
        val = readl(GPIO1_DR);
        val &= ~(1 << 3);
        writel(val,GPIO1_DR);
    }else if(sta == LEDOFF){
        val = readl(GPIO1_DR);
        val |= (1 << 3);
        writel(val,GPIO1_DR);
    }

}

static int dtsled_open(struct inode *inode,struct file *filp)
{
    filp->private_data = &dtsled;
    return 0;
}

static int dtsled_release(struct inode *inode,struct file *filp)
{
    struct dtsled_dev *dev = (struct dtsled_dev*)filp->private_data;
    return 0;
}

static ssize_t dtsled_write(struct file *filp,const char __user *buf,
             size_t count,loff_t *ppos)
{
    struct dtsled_dev *dev = (struct dtsled_dev*)filp->private_data;

    int retvalue;
    unsigned char databuf[1];
    
    retvalue = copy_from_user(databuf, buf, count);
    if(retvalue < 0) {
          return -EFAULT;
    }
    led_switch(databuf[0]);

    return 0;
}

static const struct file_operations dtsled_fops = {
    .owner = THIS_MODULE,
    .write = dtsled_write,
    .open = dtsled_open,
    .release = dtsled_release,
};

static int __init dtsled_init(void)
{
    int ret = 0;
    const char *str;
    u32 regdata[10];
    u8 i = 0;
    unsigned int val = 0;

    dtsled.major = 0;
    if(dtsled.major){
        dtsled.devid = MKDEV(dtsled.major,0);
        ret = register_chrdev_region(dtsled.devid,DTSLED_CNT,DTSLED_NAME);
    }else{
        ret = alloc_chrdev_region(&dtsled.devid,0,DTSLED_CNT,DTSLED_NAME);
        dtsled.major = MAJOR(dtsled.devid);
        dtsled.minor = MINOR(dtsled.devid);
    }
    
    if(ret < 0){
        goto fail_devid;
    }

    dtsled.cdev.owner = THIS_MODULE;
    cdev_init(&dtsled.cdev,&dtsled_fops);
    ret = cdev_add(&dtsled.cdev,dtsled.devid,DTSLED_CNT);
    if(ret < 0){
        goto fail_cdev;
    }

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

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

    dtsled.nd = of_find_node_by_path("/alphaled");
    if(dtsled.nd == NULL){
        ret = -EINVAL;
        goto fail_findnd;
    }

    ret = of_property_read_string(dtsled.nd,"status",&str);
    if(ret < 0){
        goto fail_rs;
    }
    else{
        printk("status = %s\r\n",str);
    }

    ret = of_property_read_string(dtsled.nd,"compatible",&str);
    if(ret < 0){
        goto fail_rs;
    }
    else{
        printk("compatible = %s\r\n",str);
    }

    ret = of_property_read_u32_array(dtsled.nd,"reg",regdata,10);
    if(ret < 0){
        goto fail_rs;
    }
    else{
        printk("reg data:\r\n",str);
        for(i = 0;i < 10;i++){
            printk("%#X ",regdata[i]);
        }
        printk("\r\n");
    }

    IMX6U_CCM_CCGR1 = ioremap(regdata[0], regdata[1]);
    SW_MUX_GPIO1_IO03 = ioremap(regdata[2], regdata[3]);
    SW_PAD_GPIO1_IO03 = ioremap(regdata[4], regdata[5]);
    GPIO1_DR = ioremap(regdata[6], regdata[7]);
    GPIO1_GDIR = ioremap(regdata[8], regdata[9]);

    val = readl(IMX6U_CCM_CCGR1);
    val &= ~(3 << 26); /* 清楚以前的设置 */
    val |= (3 << 26); /* 设置新值 */
    writel(val, IMX6U_CCM_CCGR1);

    writel(5, SW_MUX_GPIO1_IO03);
    writel(0x10B0, SW_PAD_GPIO1_IO03);

    val = readl(GPIO1_GDIR);
    val |= (1 << 3); /* 设置为输出 */
    writel(val, GPIO1_GDIR);

    val = readl(GPIO1_DR);
    val |= (1 << 3); 
    writel(val, GPIO1_DR);

    return 0;
    
fail_rs:
fail_findnd:
    device_destroy(dtsled.class,dtsled.devid);
fail_device:
    class_destroy(dtsled.class);
fail_class:
    cdev_del(&dtsled.cdev);
fail_cdev:
     unregister_chrdev_region(dtsled.devid,DTSLED_CNT);
fail_devid:
    return ret;
}
static void __exit dtsled_exit(void)
{
   unsigned int val = 0;
   val = readl(GPIO1_DR);
   val |= (1 << 3);
   writel(val,GPIO1_DR);

   iounmap(IMX6U_CCM_CCGR1);
   iounmap(SW_MUX_GPIO1_IO03);
   iounmap(SW_PAD_GPIO1_IO03);
   iounmap(GPIO1_DR);
   iounmap(GPIO1_GDIR);

   cdev_del(&dtsled.cdev);
   unregister_chrdev_region(dtsled.devid,DTSLED_CNT); 
   device_destroy(dtsled.class,dtsled.devid);
   class_destroy(dtsled.class);
}

module_init(dtsled_init);
module_exit(dtsled_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("mxh");

编写测试ledAPP.c

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

#define LEDOFF 0
#define LEDON 1

int main(int argc,char *argv[])
{
    int fd,retvalue;
    char *filename;
    unsigned char databuf[1];

    if(argc != 3){
        printf("Error Usage!\r\n");
        return -1;
    }
    filename = argv[1];

    fd = open(filename,O_RDWR);
    if(fd < 0)
    {
        printf("file %s open failed!\r\n",filename);
        return -1;
    }
    databuf[0] = atoi(argv[2]);
    retvalue = write(fd,databuf,sizeof(databuf));
    if(retvalue < 0){
        printf("LED Control Failed!\r\n");
        close(fd);
        return -1;
    }

    close(fd);
    return 0;
}

修改Makefile

KERNELDIR := /home/mxh/linux/IMX6ULL/linux/linux-imx-rel_imx_4.1.15_2.1.0_ga

CURRENT_PATH := $(shell pwd)

obj-m := dtsled.o

build: kernel_modules

kernel_modules:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules 
clean:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

编译

make -j4

arm-linux-gnueabihf-gcc ledAPP.c -o ledAPP

将上面编译出来的dtsled.ko和ledAPP这两个文件拷贝到rootfs/lib/modules/4.1.15目录，进入到lib/modules/4.1.15，输入如下命令加载dtsled.ko

depmod
modprobe dtsled.ko

加载成功以后测试

./ledAPP /dev/led 1
./ledAPP /dev/led 0